diskmelts 2.1__py3-none-any.whl

diskmelts/consub/_core.py

@@ -0,0 +1,447 @@
+"""Continuum fitting internals and diagnostic helpers (wavelengths in microns).
+
+Only NumPy, SciPy, and pandas are required for fitting. FITS I/O and plotting
+import astropy and matplotlib lazily.
+"""
+from pathlib import Path
+import warnings
+
+import numpy as np
+import pandas as pd
+from scipy.interpolate import PchipInterpolator
+from scipy.ndimage import maximum_filter1d
+from scipy.sparse import diags
+from scipy.sparse.linalg import spsolve
+from scipy.special import expit
+
+HERE = Path(__file__).resolve().parent
+PRESETS = {
+    "water": ("H2O",),
+    "ttauri": ("H2O", "C2H2", "HCN", "CO2"),
+    "carbon_rich": ("H2O", "C2H2", "HCN", "CO2", "13C12CH2",
+                    "13CO2", "C4H2", "HC3N", "CH4"),
+    "carbon_extended": ("H2O", "C2H2", "HCN", "CO2", "13C12CH2",
+                        "13CO2", "C4H2", "HC3N", "CH4", "C2H4"),
+}
+# C2H6 is opt-in: its local 400 K template is nonfinite at 5.70–7.58 µm.
+# generate_line_free_regions(..., molecules=[...]) supports it conservatively.
+__all__ = ["subtract_continuum", "generate_line_free_regions", "load_regions",
+           "plot_consub", "read_spectrum", "save_consub"]
+
+
+def _regions(regions):
+    if regions is None:
+        return np.empty((0, 2))
+    if isinstance(regions, (str, Path)):
+        regions = pd.read_csv(regions)
+    if isinstance(regions, pd.DataFrame):
+        if not {"xmin", "xmax"}.issubset(regions.columns):
+            raise ValueError("Line-free CSV/table must contain xmin and xmax columns")
+        regions = regions[["xmin", "xmax"]].to_numpy()
+    a = np.asarray(regions, dtype=float)
+    if a.size == 0:
+        return np.empty((0, 2))
+    if a.ndim != 2 or a.shape[1] != 2 or not np.all(np.isfinite(a)) or np.any(a[:, 1] <= a[:, 0]):
+        raise ValueError("Regions must be finite (xmin, xmax) pairs with xmin < xmax")
+    return a
+
+
+def _inside(x, regions):
+    mask = np.zeros(len(x), dtype=bool)
+    for low, high in _regions(regions):
+        mask |= (x >= low) & (x <= high)
+    return mask
+
+
+def _intervals(x, mask, min_points=2):
+    edges = np.flatnonzero(np.diff(np.r_[False, mask, False].astype(int)))
+    boundaries = np.r_[x[0], (x[:-1]+x[1:])/2, x[-1]]
+    return pd.DataFrame([(boundaries[a], boundaries[b]) for a, b in edges.reshape(-1, 2)
+                         if b-a >= min_points], columns=["xmin", "xmax"])
+
+
+def load_regions(preset="ttauri"):
+    """Read shipped candidate windows; these are references, not guarantees."""
+    if preset not in PRESETS:
+        raise ValueError(f"preset must be one of {tuple(PRESETS)}")
+    return pd.read_csv(HERE / "regions" / f"{preset}.csv")
+
+
+def generate_line_free_regions(grid_root, preset="ttauri", *, molecules=None,
+                               threshold=0.03, padding_kms=40.0,
+                               exclude=None, reference_file=None):
+    """Find windows faint in every selected model, on the model wavelength axis.
+
+    H2O: T=800 K, logN=18; all carbon species: T=400 K, logN=16.
+    Threshold is a fraction of a rolling 0.5 micron peak, floored at 2% of
+    the full model peak. Padding is a wavelength-registration margin; models
+    already contain instrumental broadening. Outside model coverage is unknown.
+    Optional reference_file intersects the candidates with curated windows.
+    """
+    if preset not in PRESETS or not 0 < threshold < 1 or padding_kms < 0:
+        raise ValueError("Invalid preset, threshold, or padding_kms")
+    species = tuple(PRESETS[preset] if molecules is None else molecules)
+    if not species:
+        raise ValueError("Select at least one molecule")
+    x = None
+    clean = None
+    missing = {}
+    for molecule in species:
+        temperature, column = (800, 18) if molecule == "H2O" else (400, 16)
+        path = Path(grid_root) / molecule / f"T{temperature}N{column}.0.csv"
+        table = pd.read_csv(path)
+        mx = table["wave"].to_numpy(float)
+        my = table["Line"].to_numpy(float)
+        if np.any(np.diff(mx) <= 0) or not np.all(np.isfinite(mx)) or not np.any(np.isfinite(my)) or np.nanmax(my) <= 0:
+            raise ValueError(f"Invalid template: {path}")
+        unknown = ~np.isfinite(my)
+        missing[molecule] = int(unknown.sum())
+        my = np.where(unknown, 0, my)
+        if x is None:
+            x, clean = mx, np.ones(len(mx), dtype=bool)
+        window = max(3, int(0.5 / np.median(np.diff(mx))) | 1)
+        envelope = np.maximum(maximum_filter1d(my, window), 0.02 * np.max(my))
+        line = (my / envelope > threshold) | unknown
+        # Pad intervals on the native axis before interpolating masks, so a
+        # narrow line cannot disappear between samples of a coarser spectrum.
+        intervals = _intervals(mx, line, min_points=1).to_numpy()
+        if len(intervals):
+            intervals[:, 0] *= 1 - padding_kms / 299792.458
+            intervals[:, 1] *= 1 + padding_kms / 299792.458
+        clean &= ~_inside(x, intervals)
+        clean &= (x >= mx[0]) & (x <= mx[-1])
+    exclusions = list(_regions(exclude))
+    if preset.startswith("carbon_"):
+        exclusions.append((12.5, 16.5))
+    clean &= ~_inside(x, exclusions)
+    if reference_file is not None:
+        clean &= _inside(x, reference_file)
+    result = _intervals(x, clean)
+    result["lam"] = (result.xmin + result.xmax) / 2
+    result.attrs.update(preset=preset, molecules=list(species), threshold=threshold,
+                        padding_kms=padding_kms, unknown_template_pixels=missing)
+    return result
+
+
+def _mad(a):
+    a = np.asarray(a)
+    return 1.4826 * np.median(np.abs(a - np.median(a)))
+
+
+def _interp(x, xp, yp):
+    if len(xp) == 1:
+        return np.full(len(x), yp[0])
+    # Constant end corrections avoid unstable polynomial extrapolation.
+    return PchipInterpolator(xp, yp)(np.clip(x, xp[0], xp[-1]))
+
+
+def _widths(x, good, boxsizes):
+    dx = np.gradient(x)
+    if boxsizes is None:
+        # Expand to about 31 clean pixels; retain a physical lower limit so
+        # the baseline does not track resolved molecular lines.
+        n = np.convolve(good.astype(float), np.ones(min(101, len(x))), "same")
+        fraction = np.maximum(n / min(101, len(x)), 0.05)
+        return np.clip(31 * dx / fraction, 0.25, 1.0)
+    if np.isscalar(boxsizes):
+        if not np.isfinite(boxsizes) or boxsizes < 5:
+            raise ValueError("boxsizes must be at least 5 pixels")
+        return dx * float(boxsizes)
+    widths = _widths(x, good, None)
+    for low, high, pixels in boxsizes:
+        if not np.isfinite([low, high, pixels]).all() or high <= low or pixels < 5:
+            raise ValueError("boxsizes entries must be (xmin, xmax, pixels>=5)")
+        sel = (x >= low) & (x <= high)
+        widths[sel] = dx[sel] * pixels
+    return widths
+
+
+def _local_baseline(x, y, noise, good, widths):
+    positions, values = [], []
+    # Local linear fits remove slope before clipping, unlike selecting minima.
+    centers = np.arange(x[0], x[-1], max(0.04, np.median(widths) / 3))
+    centers = np.unique(np.r_[x[0], centers, x[-1]])
+    for center in centers:
+        width = np.interp(center, x, widths)
+        sel = good & (np.abs(x-center) <= width/2)
+        if np.count_nonzero(sel) < 5:
+            continue
+        xx, yy, nn = x[sel]-center, y[sel], noise[sel]
+        keep = np.ones(len(xx), dtype=bool)
+        for _ in range(6):
+            if np.sum(keep) < 4:
+                break
+            coef = np.polyfit(xx[keep], yy[keep], 1, w=1/nn[keep])
+            residual = yy - np.polyval(coef, xx)
+            scale = np.maximum(nn, _mad(residual[keep]))
+            updated = (residual < 2.5*scale) & (residual > -4*scale)
+            if np.array_equal(keep, updated):
+                break
+            keep = updated
+        if np.sum(keep) < 4:
+            continue
+        # Place the knot at the actual support, not the nominal box center:
+        # extrapolating a slope from a tiny off-center cluster creates spikes.
+        location = np.median(xx[keep])
+        positions.append(center+location)
+        values.append(float(np.polyval(coef, location)))
+    if len(positions) < 3:
+        raise ValueError("Too few continuum windows; widen boxsizes or revise masks")
+    knots = pd.DataFrame({"x": positions, "y": values}).groupby("x", sort=True).median()
+    return _interp(x, knots.index.to_numpy(), knots.y.to_numpy())
+
+
+def _arpls(x, y, noise, good, widths):
+    # Nonuniform-grid second derivatives, scaled to a median pixel spacing.
+    h = np.diff(x) / np.median(np.diff(x))
+    a = 2 / (h[:-1] * (h[:-1]+h[1:]))
+    c = 2 / (h[1:] * (h[:-1]+h[1:]))
+    derivative = diags([a, -a-c, c], [0, 1, 2], shape=(len(x)-2, len(x)))
+    lam = (widths[1:-1] / (2*np.pi*np.median(np.diff(x))))**4
+    penalty = derivative.T @ diags(lam) @ derivative
+    base = good.astype(float) * (np.median(noise[good])/noise)**2
+    weights = base.copy()
+    converged = False
+    for _ in range(40):
+        z = spsolve(diags(weights) + penalty, weights*y)
+        residual = y-z
+        negative = residual[good & (residual < 0)]
+        if len(negative) < 3:
+            break
+        scale = max(np.std(negative), np.median(noise[good])*0.1)
+        new = base * expit(-2*(residual - (2*scale-np.mean(negative)))/scale)
+        # Strong negative defects must not pin the baseline downward.
+        new[residual < -5*np.maximum(noise, scale)] = 0
+        if np.linalg.norm(new-weights) / max(np.linalg.norm(weights), 1e-15) < 1e-3:
+            converged = True
+            break
+        weights = new
+    return z, converged
+
+
+def subtract_continuum(wav, flux, *, error=None, exclude=None, boxsizes=None,
+                       special=None, preset="ttauri", line_free_regions=None,
+                       reference_regions="curated",
+                       auto_mask=True, method="robust", shift=True,
+                       correction_scale=0.75, special_blend=0.15):
+    """Return a DataFrame containing the spectrum, continuum and diagnostics.
+
+    boxsizes: None (automatic), a pixel count, or (xmin,xmax,pixels) rows.
+    special: windows where the reference-window correction is suppressed.
+    line_free_regions: pairs, CSV path, or xmin/xmax DataFrame; overrides preset.
+    exclude always wins over references. Nonfinite flux is retained as NaN;
+    wavelength must be finite, positive, unique, and strictly increasing.
+    err is measurement/local-noise error; cont_err is a separate diagnostic
+    uncertainty, not a calibrated posterior. With preset=None and no custom
+    windows, all nonexcluded pixels are used and reference correction is off.
+    """
+    x, original = np.asarray(wav, float), np.asarray(flux, float)
+    if x.ndim != 1 or original.shape != x.shape or len(x) < 15:
+        raise ValueError("wav and flux must be matching 1D arrays with >=15 samples")
+    if not np.all(np.isfinite(x)) or np.any(x <= 0) or np.any(np.diff(x) <= 0):
+        raise ValueError("wav must be finite, positive, and strictly increasing")
+    if method not in ("robust", "arpls") or correction_scale <= 0 or special_blend < 0:
+        raise ValueError("Invalid method or correction/blend scale")
+    if preset is not None and preset not in PRESETS:
+        raise ValueError(f"preset must be one of {tuple(PRESETS)}")
+    finite = np.isfinite(original)
+    if finite.sum() < 15:
+        raise ValueError("At least 15 finite flux samples are required")
+    original = original.copy()
+    original[~finite] = np.nan
+    unrestricted = preset is None and line_free_regions is None
+    if unrestricted:
+        refs = np.array([[x[0], x[-1]]])
+        shift = False
+    else:
+        refs = _regions(load_regions(preset) if line_free_regions is None else line_free_regions)
+    excluded = _inside(x, exclude)
+    if preset is not None and preset.startswith("carbon_"):
+        excluded |= _inside(x, [(12.5, 16.5)])
+    reference = _inside(x, refs) & finite & ~excluded
+    good = finite & ~excluded
+    if auto_mask:
+        good &= reference
+    if isinstance(reference_regions, str) and reference_regions == "curated":
+        if preset is not None:
+            filename = "cont_ranges_PPan.csv" if preset.startswith("carbon_") else "cont_ranges.csv"
+            reference &= _inside(x, HERE / filename)
+    elif reference_regions is not None:
+        reference &= _inside(x, reference_regions)
+    if good.sum() < 15:
+        raise ValueError("Fewer than 15 usable continuum pixels; revise regions")
+    y = np.interp(x, x[finite], original[finite])
+    # Adjacent differences estimate noise without a continuum-level assumption.
+    noise_x, noise_y = [], []
+    for lo in np.arange(x[0], x[-1], 0.75):
+        adjacent = finite[:-1] & finite[1:] & (x[:-1] >= lo) & (x[1:] < lo+0.75)
+        delta = np.diff(y)[adjacent]
+        if len(delta) >= 5:
+            noise_x.append(lo+0.375)
+            noise_y.append(_mad(delta)/np.sqrt(2))
+    floor = max(np.nanmedian(np.abs(y))*1e-10, np.finfo(float).eps)
+    if not noise_x:
+        noise_x, noise_y = [np.median(x)], [_mad(np.diff(y))/np.sqrt(2)]
+    estimated_noise = np.maximum(_interp(x, noise_x, noise_y), floor)
+    if error is None:
+        measurement = estimated_noise.copy()
+    else:
+        measurement = np.asarray(error, float).copy()
+        if measurement.shape != x.shape:
+            raise ValueError("error must have the same shape as wav")
+        invalid_error = ~np.isfinite(measurement) | (measurement <= 0)
+        measurement[invalid_error] = estimated_noise[invalid_error]
+    noise = np.maximum(measurement, estimated_noise)
+    widths = _widths(x, good, boxsizes)
+    # Remove isolated negative spikes from fitting, never from returned flux.
+    neighbors = (np.roll(y, 1)+np.roll(y, -1))/2
+    spikes = (neighbors-y > 6*noise)
+    spikes[[0, -1]] = False
+    good &= ~spikes
+    reference &= ~spikes
+    converged = True
+    if method == "robust":
+        baseline = _local_baseline(x, y, noise, good, widths)
+    else:
+        baseline, converged = _arpls(x, y, noise, good, widths)
+        if not converged:
+            warnings.warn("arPLS did not converge in 40 iterations", stacklevel=2)
+    # Bin reference residuals before shape-preserving interpolation. This
+    # prevents a dense cluster of narrow windows dominating a global polynomial.
+    anchor_x, anchor_y, anchor_err = [], [], []
+    for lo in np.arange(x[0], x[-1], correction_scale):
+        sel = reference & (x >= lo) & (x < lo+correction_scale)
+        if sel.sum() < 5:
+            continue
+        residual = y[sel]-baseline[sel]
+        center = np.median(residual)
+        scatter = max(_mad(residual), np.median(noise[sel]))
+        accepted = np.abs(residual-center) < 3*scatter
+        if accepted.sum() < 5:
+            continue
+        anchor_x.append(float(np.median(x[sel][accepted])))
+        anchor_y.append(float(np.median(residual[accepted])))
+        # Samples within one resolution element are correlated; this is still
+        # only an indicative anchor error, supplemented by baseline sensitivity.
+        anchor_err.append(float(1.253*scatter/np.sqrt(max(1, accepted.sum()/3))))
+    if not anchor_x:
+        raise ValueError("Too few reference anchors; supply broader line-free windows")
+    correction = _interp(x, anchor_x, anchor_y) if shift else np.zeros(len(x))
+    taper = np.ones(len(x))
+    for lo, hi in _regions(special):
+        if special_blend == 0:
+            taper[(x >= lo) & (x <= hi)] = 0
+        else:
+            # Exact zero inside the special window, smooth transitions outside.
+            left = np.clip((x-(lo-special_blend))/special_blend, 0, 1)
+            right = np.clip(((hi+special_blend)-x)/special_blend, 0, 1)
+            blend = (left*left*(3-2*left)) * (right*right*(3-2*right))
+            taper *= 1-blend
+    correction *= taper
+    continuum = baseline+correction
+    # Report baseline dependence on a factor-of-two smoothing change separately.
+    if method == "robust":
+        alternate = _local_baseline(x, y, noise, good, widths*2)
+    else:
+        alternate, _ = _arpls(x, y, noise, good, widths*2)
+    sensitivity = np.abs(alternate-baseline)
+    cont_error = np.hypot(_interp(x, anchor_x, anchor_err), sensitivity)
+    # Distance to available reference pixels flags interpolation across holes.
+    idx = np.searchsorted(x[reference], x)
+    left = x[reference][np.clip(idx-1, 0, reference.sum()-1)]
+    right = x[reference][np.clip(idx, 0, reference.sum()-1)]
+    unsupported = np.minimum(np.abs(x-left), np.abs(x-right)) > np.maximum(widths, correction_scale)/2
+    unsupported |= (x < x[reference][0]) | (x > x[reference][-1])
+    cont_error[unsupported] = np.nan
+    if unsupported.any():
+        warnings.warn("Continuum crosses regions with weak support; inspect the plot or "
+                      "subtract_continuum() diagnostics before using those regions", stacklevel=2)
+    result = pd.DataFrame({"wave": x, "flux": original-continuum,
+                           "err": measurement, "cont": continuum,
+                           "cont_unshifted": baseline, "raw_flux": original,
+                           "cont_err": cont_error, "cont_sensitivity": sensitivity,
+                           "noise": noise, "correction": correction,
+                           "fit_mask": good, "reference_mask": reference,
+                           "excluded": excluded, "weak_support": unsupported,
+                           "box_um": widths})
+    result.attrs.update(preset=preset, method=method, converged=converged,
+                        reference_source="unrestricted" if unrestricted else "windows",
+                        anchor_wave=anchor_x, anchor_offset=anchor_y,
+                        anchor_error=anchor_err, special=_regions(special).tolist())
+    return result
+
+
+def read_spectrum(path):
+    """Read local JWST FITS or CSV with wave/flux[/err] columns."""
+    path = Path(path)
+    if path.suffix.lower() in (".fits", ".fit"):
+        try:
+            from astropy.io import fits
+        except ImportError as exc:
+            raise ImportError('FITS reading requires astropy: pip install "diskmelts[io]"') from exc
+        with fits.open(path) as hdus:
+            data = hdus[1].data
+            return tuple(np.asarray(data[key], float).copy() for key in
+                         ("wavelength", "fluxdensity", "fluxdensity_stddev"))
+    table = pd.read_csv(path)
+    return (table.wave.to_numpy(), table.flux.to_numpy(),
+            table.err.to_numpy() if "err" in table else None)
+
+
+def save_consub(result, path):
+    """Write all numeric diagnostics; first four columns match DiskMELTS I/O."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    result.to_csv(path, index=False)
+    return path
+
+
+def plot_consub(result, ranges=None, *, title=None, output=None):
+    """Plot the continuum and residual with reference, exclusion, and support masks."""
+    import matplotlib.pyplot as plt
+    x = result.wave.to_numpy()
+    if ranges is None:
+        ranges = [(x[0], x[-1])]
+    if np.asarray(ranges).shape == (2,):
+        ranges = [ranges]
+    ranges = _regions(ranges)
+    if not len(ranges):
+        raise ValueError("At least one plotting range is required")
+    fig, axes = plt.subplots(2*len(ranges), 1, figsize=(12, 4*len(ranges)),
+                             squeeze=False, constrained_layout=True)
+    for i, (lo, hi) in enumerate(ranges):
+        sel = (x >= lo) & (x <= hi)
+        if not sel.any():
+            plt.close(fig)
+            raise ValueError(f"No data in plotting range {lo}, {hi}")
+        a, b = axes[2*i, 0], axes[2*i+1, 0]
+        a.plot(x[sel], result.raw_flux[sel], color="0.55", lw=0.6, label="Raw")
+        if "cont_unshifted" in result:
+            a.plot(x[sel], result.cont_unshifted[sel], color="darkorange", lw=1, label="Unshifted continuum")
+        a.plot(x[sel], result.cont[sel], color="tab:blue", lw=1.2, label="Continuum")
+        ref = sel & result.reference_mask.to_numpy()
+        if ref.any():
+            a.scatter(x[ref], result.raw_flux[ref], s=7, color="seagreen",
+                      alpha=.8, zorder=4, label="Calibration pixels")
+        b.plot(x[sel], result.flux[sel], color="0.2", lw=0.6)
+        if "err" in result:
+            b.fill_between(x[sel], -result.err[sel], result.err[sel], color="tab:blue", alpha=.15, label="Measurement/noise error")
+        b.axhline(0, color="tab:blue", lw=.7)
+        for axis in (a, b):
+            if "excluded" in result:
+                for j, row in _intervals(x, result.excluded.to_numpy()).iterrows():
+                    axis.axvspan(row.xmin, row.xmax, color="lightcoral", alpha=.2,
+                                 label="Excluded" if axis is a and j == 0 else None)
+            for j, row in _intervals(x, result.weak_support.to_numpy()).iterrows():
+                axis.axvspan(row.xmin, row.xmax, color="orange", alpha=.12,
+                             label="Weak continuum support" if axis is a and j == 0 else None)
+            axis.set_xlim(lo, hi)
+            axis.set_ylabel("Flux density")
+        a.legend(fontsize=8, ncol=4)
+        b.set_xlabel("Wavelength (µm)")
+    if title:
+        fig.suptitle(title)
+    if output is not None:
+        Path(output).parent.mkdir(parents=True, exist_ok=True)
+        fig.savefig(output, dpi=160)
+    return fig

diskmelts/consub/cont_ranges.csv

@@ -0,0 +1,206 @@
+xmin,xmax,lam
+4.9116,4.9136,4.9126
+4.9623,4.9639,4.9631
+4.974,4.9763,4.97515
+4.9856,4.9881,4.98685
+5.0493,5.0506,5.04995
+5.1011,5.1029,5.102
+5.1775,5.183,5.18025
+5.191,5.1936,5.1923
+5.2881,5.29,5.28905
+5.3272,5.3293,5.32825
+5.3953,5.3974,5.39635
+5.4462,5.4483,5.44725
+5.4717,5.4747,5.4732
+5.4958,5.4987,5.49725
+5.5728,5.5751,5.57395
+5.6065,5.6092,5.60785
+5.6356,5.6376,5.6366
+5.6698,5.6722,5.671
+5.6964,5.6988,5.6976
+5.7572,5.7604,5.7588
+5.8111,5.8143,5.8127
+5.8538,5.855,5.8544
+5.9861,5.9875,5.9868
+5.998,6.0025,6.00025
+6.0829,6.0858,6.08435
+6.0918,6.0941,6.09295
+6.1246,6.133,6.1288
+6.1781,6.1819,6.18
+6.1888,6.1914,6.1901
+6.1957,6.1972,6.19645
+6.2093,6.2107,6.21
+6.2307,6.2338,6.23225
+6.249,6.2522,6.2506
+6.2739,6.2755,6.2747
+6.2966,6.2992,6.2979
+6.3063,6.3123,6.3093
+6.3214,6.324,6.3227
+6.3276,6.3302,6.3289
+6.3472,6.3493,6.34825
+6.36,6.3631,6.36155
+6.3934,6.3959,6.39465
+6.446,6.4479,6.44695
+6.4627,6.4665,6.4646
+6.5334,6.5368,6.5351
+6.6043,6.6091,6.6067
+6.6506,6.6536,6.6521
+6.8935,6.8987,6.8961
+7.0048,7.0063,7.00555
+7.1594,7.1611,7.16025
+7.1808,7.1857,7.18325
+7.2665,7.268,7.26725
+7.3097,7.3151,7.3124
+7.4449,7.4465,7.4457
+7.5599,7.5657,7.5628
+7.6238,7.6262,7.625
+7.6344,7.6357,7.63505
+7.6474,7.6495,7.64845
+7.672,7.6759,7.67395
+7.8181,7.8232,7.82065
+7.8442,7.8482,7.8462
+7.9177,7.9196,7.91865
+7.9283,7.9304,7.92935
+7.949,7.9511,7.95005
+7.9711,7.9741,7.9726
+7.9959,7.9991,7.9975
+8.0023,8.0071,8.0047
+8.0639,8.0658,8.06485
+8.0997,8.1019,8.1008
+8.1343,8.1368,8.13555
+8.1784,8.1803,8.17935
+8.2169,8.2202,8.21855
+8.2911,8.3035,8.2973
+8.3103,8.3138,8.31205
+8.3596,8.362,8.3608
+8.3837,8.3861,8.3849
+8.4014,8.4095,8.40545
+8.417,8.4203,8.41865
+8.4652,8.4684,8.4668
+8.6232,8.6257,8.62445
+8.6917,8.6953,8.6935
+8.7252,8.7291,8.72715
+8.7383,8.7407,8.7395
+8.7765,8.7836,8.78005
+8.8532,8.8579,8.85555
+8.8919,8.8999,8.8959
+8.908,8.9115,8.90975
+8.9367,8.939,8.93785
+9.0049,9.0184,9.01165
+9.0718,9.0886,9.0802
+9.1122,9.1163,9.11425
+9.1904,9.1928,9.1916
+9.2005,9.2046,9.20255
+9.2323,9.2414,9.23685
+9.2738,9.2761,9.27495
+9.3016,9.3049,9.30325
+9.3293,9.3346,9.33195
+9.3394,9.3418,9.3406
+9.4133,9.4301,9.4217
+9.4984,9.5027,9.50055
+9.5316,9.5572,9.5444
+9.6112,9.6162,9.6137
+9.6315,9.6408,9.63615
+9.6474,9.6537,9.65055
+9.6896,9.7004,9.695
+9.7207,9.7429,9.7318
+9.7633,9.7788,9.77105
+9.9701,9.9847,9.9774
+10.1043,10.1081,10.1062
+10.1215,10.1257,10.1236
+10.1436,10.1575,10.15055
+10.1778,10.2147,10.19625
+10.2385,10.2427,10.2406
+10.5154,10.5221,10.51875
+10.6155,10.6235,10.6195
+10.7052,10.709,10.7071
+10.7168,10.7208,10.7188
+10.7408,10.7521,10.74645
+10.7862,10.7948,10.7905
+10.8355,10.8396,10.83755
+10.8587,10.8653,10.862
+10.9083,10.9278,10.91805
+10.9468,10.9683,10.95755
+11.0964,11.1153,11.10585
+11.1248,11.1353,11.13005
+11.1826,11.2002,11.1914
+11.2233,11.2263,11.2248
+11.2744,11.2873,11.28085
+11.3325,11.342,11.33725
+11.3434,11.3528,11.3481
+11.3667,11.3782,11.37245
+11.4118,11.4257,11.41875
+11.4615,11.4741,11.4678
+11.5074,11.5196,11.5135
+11.5784,11.5881,11.58325
+11.6388,11.6419,11.64035
+11.6573,11.6715,11.6644
+11.6885,11.6963,11.6924
+11.8411,11.8494,11.84525
+11.9943,11.9992,11.99675
+12.1235,12.1325,12.128
+12.3011,12.3099,12.3055
+12.3284,12.3376,12.333
+12.4631,12.4735,12.4683
+12.4851,12.492,12.48855
+12.9342,12.9499,12.94205
+12.9918,12.9985,12.99515
+13.0507,13.0559,13.0533
+13.2126,13.2171,13.21485
+14.4352,14.4464,14.4408
+14.5592,14.5773,14.56825
+14.7371,14.7743,14.7557
+15.0093,15.0295,15.0194
+15.2019,15.2213,15.2116
+15.5324,15.5443,15.53835
+15.7069,15.7157,15.7113
+15.9071,15.9201,15.9136
+15.9353,15.9467,15.941
+16.088,16.0965,16.09225
+16.2848,16.2993,16.29205
+16.3382,16.3597,16.34895
+16.9533,16.9668,16.96005
+17.0154,17.0244,17.0199
+17.2836,17.2999,17.29175
+17.4159,17.4377,17.4268
+17.5482,17.5558,17.552
+17.5816,17.5864,17.584
+17.6618,17.667,17.6644
+17.8546,17.8643,17.85945
+17.8835,17.9003,17.8919
+17.9729,18.0153,17.9941
+18.0936,18.1,18.0968
+18.4465,18.4546,18.45055
+18.5635,18.5739,18.5687
+18.7318,18.7417,18.73675
+18.8036,18.8192,18.8114
+19.1411,19.1711,19.1561
+19.3612,19.3736,19.3674
+19.5081,19.5519,19.53
+19.7016,19.7154,19.7085
+19.8536,19.8626,19.8581
+20.402,20.4148,20.4084
+20.584,20.63,20.607
+20.72,20.735,20.7275
+20.83,20.85,20.84
+20.9537,20.9769,20.9653
+21.3018,21.3145,21.30815
+21.391,21.4083,21.39965
+21.4802,21.5013,21.49075
+22.0572,22.0642,22.0607
+22.1515,22.1722,22.16185
+22.683,22.6975,22.69025
+22.9341,22.9496,22.94185
+23.0229,23.0506,23.03675
+23.7182,23.7318,23.725
+23.965,24.044,24.0045
+24.228,24.2412,24.2346
+24.2717,24.2872,24.27945
+24.3374,24.3492,24.3433
+24.8524,24.8844,24.8684
+25.2745,25.2984,25.28645
+25.7801,25.8158,25.79795
+26.28,26.4003,26.34015
+26.815,26.89,26.8525
+26.9341,26.98,26.95705
+27.1487,27.1768,27.16275