eclipse 0.13.0__py3-none-any.whl

eclipse/continuum.py

@@ -0,0 +1,413 @@
+"""
+Continuum under the lines: free-free, free-bound and two-photon emission.
+
+Computed from CHIANTI through fiasco for every element, with the same
+abundances and ionisation fractions as the lines. Like a contribution
+function, it multiplies an emission measure of n_e^2 dh, so fiasco's values
+are multiplied by n_H / n_e and divided by 4 pi. Only two-photon emission
+depends on density. In a synthesis file, each group of overlapping windows
+gets one continuum entry, which the instrument run adds to every window it
+reaches.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import numpy as np
+import astropy.units as u
+
+# Name prefix of a continuum entry in a synthesis file, followed by the
+# wavelength range of its window group in Angstrom.
+CONTINUUM_PREFIX = "continuum"
+# Unit of the continuum per emission measure: spectral radiance per
+# n_e^2 dh, with wavelengths in cm, as for ECLIPSE's line spectra.
+EMISSIVITY_UNIT = u.erg * u.cm**3 / (u.s * u.sr * u.cm)
+
+
+def is_continuum(name: str) -> bool:
+    """Whether synthesis file entry `name` is the continuum rather than a line."""
+    return name.startswith(CONTINUUM_PREFIX + "_")
+
+
+def continuum_windows(wavelengths: Sequence[u.Quantity]) -> Dict[str, u.Quantity]:
+    """
+    Wavelengths of the continuum entries covering a set of spectral windows.
+
+    Each window wavelength covers the bin halfway to its neighbours. The
+    bins of the end wavelengths extend the same distance outward. Windows
+    whose bins overlap are grouped. Each group gets one evenly spaced grid,
+    at the smallest spacing of its windows, whose bins cover all of theirs.
+    Groups do not overlap, so no wavelength is in two entries.
+
+    Parameters
+    ----------
+    wavelengths : sequence of u.Quantity
+        Wavelengths of each line, increasing, as in `wl_grid` from
+        `synthesise_spectra`.
+
+    Returns
+    -------
+    dict
+        Wavelengths in cm for each group, keyed by entry name such as
+        `"continuum_194.9248-195.3757"`.
+    """
+    windows = []
+    for grid in wavelengths:
+        values = np.asarray(u.Quantity(grid).to_value(u.cm), dtype=float)
+        if values.size < 2:
+            raise ValueError("A spectral window needs two or more wavelengths.")
+        spacing = np.diff(values)
+        if not np.all(spacing > 0):
+            raise ValueError("A spectral window's wavelengths must increase.")
+        # The window's bins, from half a spacing before its first wavelength
+        # to half a spacing after its last.
+        windows.append((float(values[0] - spacing[0] / 2), float(values[-1] + spacing[-1] / 2),
+                        float(np.min(spacing))))
+
+    def bins(low, high, step):
+        """Number of bins of width `step` needed to reach from `low` to `high`."""
+        return int(np.ceil((high - low) / step * (1 - 1e-12)))
+
+    windows.sort()
+    groups: List[List[float]] = []
+    for low, high, step in windows:
+        # A group's bins can reach past its windows' last bin, so a window is
+        # grouped with it if it begins before the group's bins end.
+        if groups:
+            first, last, spacing = groups[-1]
+            if low < first + bins(first, last, spacing) * spacing:
+                groups[-1] = [first, max(last, high), min(spacing, step)]
+                continue
+        groups.append([low, high, step])
+    grids = {}
+    for low, high, step in groups:
+        # Bins of this spacing from the group's first bin edge to past its last.
+        grid = low + (np.arange(bins(low, high, step)) + 0.5) * step
+        name = f"{CONTINUUM_PREFIX}_{grid[0] * 1e8:.4f}-{grid[-1] * 1e8:.4f}"
+        # Windows far narrower than any line's could round to the same name.
+        if name in grids:
+            name = f"{name}_{sum(key.startswith(name) for key in grids) + 1}"
+        grids[name] = grid * u.cm
+    return grids
+
+
+def _element_continuum(args):
+    """
+    One element's continuum emission, for a worker process.
+
+    Free-free plus free-bound emission, shape `(nT, n_wavelength)`, and
+    two-photon emission, shape `(nT, nN, n_wavelength)`. Both are in
+    erg cm3 / (s Angstrom), per n_e n_H and over all directions, as fiasco
+    gives them.
+    """
+    symbol, temperature_K, wavelength_aa, densities_cm3, abundance, dbase_root = args
+    import logging
+
+    import fiasco
+    from fiasco.util.exceptions import MissingDatasetException
+
+    # fiasco skips and logs each ion lacking data for a continuum; collect
+    # them to report once, rather than a line each.
+    left_out = []
+
+    class _LeftOut(logging.Handler):
+        def emit(self, record):
+            message = record.getMessage()
+            if " not included in " in message:
+                ion, rest = message.split(" not included in ", 1)
+                # An ion with no electrons has no bound states, and so no
+                # free-bound emission to leave out.
+                if ion.split()[-1] == str(atomic_number + 1):
+                    return
+                left_out.append(f"{ion} ({rest.split(' emission')[0]})")
+
+    from .utils import element_data
+
+    atomic_number, _ = element_data(symbol)
+    logger = logging.getLogger("fiasco")
+    handler, propagate = _LeftOut(), logger.propagate
+    logger.addHandler(handler)
+    logger.propagate = False
+    single_ion = []
+    try:
+        kwargs = {} if dbase_root is None else {"hdf5_dbase_root": dbase_root}
+        element = fiasco.Element(symbol, temperature_K * u.K, abundance=abundance, **kwargs)
+        wavelength = wavelength_aa * u.AA
+        unit = u.erg * u.cm**3 / (u.s * u.AA)
+        free = (element.free_free(wavelength) + element.free_bound(wavelength)).to_value(unit)
+        density = densities_cm3 * u.cm**-3
+        two_photon = np.zeros((temperature_K.size, densities_cm3.size, wavelength_aa.size))
+        for ion in element:
+            # Only hydrogen- and helium-like ions give two-photon emission.
+            if not (ion.hydrogenic or ion.helium_like):
+                continue
+            try:
+                emission = _two_photon(ion, wavelength, density, unit, single_ion, kwargs,
+                                       abundance)
+            except MissingDatasetException:
+                left_out.append(f"{ion.ion_name} (two-photon)")
+                continue
+            try:
+                abundance_of = u.Quantity(ion.abundance).to_value(u.dimensionless_unscaled)
+            except MissingDatasetException:
+                # An element missing from the abundance set has zero abundance.
+                continue
+            share = (abundance_of
+                     * u.Quantity(ion.ionization_fraction).to_value(u.dimensionless_unscaled))
+            two_photon += emission * share[:, np.newaxis, np.newaxis]
+    finally:
+        logger.removeHandler(handler)
+        logger.propagate = propagate
+    return (symbol, free, two_photon, str(element[0].hdf5_dbase_root), left_out,
+            single_ion)
+
+
+def _beyond_the_rates(error: ValueError) -> bool:
+    """Whether fiasco stopped at a temperature beyond the rates CHIANTI tabulates."""
+    return "interpolation range" in str(error)
+
+
+def _two_photon(ion, wavelength, density, unit, single_ion: list, ion_kwargs: dict,
+                abundance: str) -> np.ndarray:
+    """
+    One ion's two-photon emission, shape (nT, nN, n_wavelength), in `unit`.
+
+    fiasco is called one density at a time, since version 0.8 fails to
+    arrange its result for several. Its level populations use level-resolved
+    recombination and ionisation rates, which for some ions CHIANTI
+    tabulates only up to some temperature. Above that, fiasco's single-ion
+    model is used, as for ions with no such rates at all, and the ion and
+    temperatures are added to `single_ion`.
+    """
+    import fiasco
+
+    def at(one_density, ions):
+        parts = []
+        for part, single in ions:
+            kwargs = {"use_two_ion_model": False} if single else {}
+            parts.append(part.two_photon(wavelength, one_density, **kwargs).to_value(unit)[:, 0])
+        return np.concatenate(parts)
+
+    ions = [(ion, False)]
+    columns = []
+    for one_density in density:
+        one_density = one_density[np.newaxis]
+        try:
+            columns.append(at(one_density, ions))
+            continue
+        except ValueError as error:
+            if not _beyond_the_rates(error) or len(ions) > 1:
+                raise
+        # First temperature beyond the rates, found once.
+        first = None
+        for index, temperature in enumerate(ion.temperature):
+            one = fiasco.Ion(ion.ion_name, temperature[np.newaxis], abundance=abundance,
+                             **ion_kwargs)
+            try:
+                one.two_photon(wavelength, one_density)
+            except ValueError as error:
+                if not _beyond_the_rates(error):
+                    raise
+                first = index
+                break
+        if first is None:
+            raise RuntimeError(f"fiasco could not work out the two-photon emission of "
+                               f"{ion.ion_name} at its temperatures together, but could at "
+                               f"each on its own.")
+        below, above = ion.temperature[:first], ion.temperature[first:]
+        ions = ([(fiasco.Ion(ion.ion_name, below, abundance=abundance, **ion_kwargs), False)]
+                if below.size else [])
+        ions.append((fiasco.Ion(ion.ion_name, above, abundance=abundance, **ion_kwargs), True))
+        single_ion.append(f"{ion.ion_name} from log T "
+                          f"{np.log10(above[0].to_value(u.K)):.2f}")
+        columns.append(at(one_density, ions))
+    return np.stack(columns, axis=1)
+
+
+def compute_continuum_fiasco(
+    wavelength: u.Quantity,
+    logT_grid: np.ndarray,
+    logN_grid: np.ndarray,
+    abundance: str = "sun_coronal_2021_chianti",
+    n_workers: int = 0,
+    hdf5_dbase_root=None,
+    elements: Optional[Sequence[str]] = None,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Continuum per emission measure, from CHIANTI through fiasco.
+
+    Parameters
+    ----------
+    wavelength : u.Quantity
+        Wavelengths to compute it at.
+    logT_grid : np.ndarray
+        Temperatures as log10(T / K), as for the lines' contribution
+        functions.
+    logN_grid : np.ndarray
+        Densities as log10(n_e / cm-3), as for the lines' contribution
+        functions, for the two-photon emission.
+    abundance : str, optional
+        CHIANTI abundance set, as for the lines. Default
+        `"sun_coronal_2021_chianti"`.
+    n_workers : int, optional
+        Number of processes for the elements. Default 0 uses every CPU
+        available to this process, up to one per element. The workers are
+        spawned, so a calling script needs an `if __name__ == "__main__":`
+        guard.
+    hdf5_dbase_root : str or Path, optional
+        CHIANTI database to read. Default fiasco's own.
+    elements : sequence of str, optional
+        Elements by symbol. Default every element in CHIANTI.
+
+    Returns
+    -------
+    free : np.ndarray
+        Free-free and free-bound emission, shape (nT, n_wavelength), in
+        erg cm3 / (s sr cm): spectral radiance per n_e^2 dh.
+    two_photon : np.ndarray
+        Two-photon emission, shape (nN, nT, n_wavelength), in the same unit,
+        on the `logN_grid` densities, like a line's `g_tn`.
+    """
+    import fiasco
+
+    from .atmosphere import _offer_database_build
+
+    dbase_root = None if hdf5_dbase_root is None else str(hdf5_dbase_root)
+    _offer_database_build(dbase_root)
+    temperature_K = 10.0 ** np.asarray(logT_grid, dtype=float)
+    densities_cm3 = 10.0 ** np.asarray(logN_grid, dtype=float)
+    wavelength_aa = np.atleast_1d(u.Quantity(wavelength).to_value(u.AA))
+    if elements is None:
+        elements = fiasco.list_elements(dbase_root)
+    worker_args = [(symbol, temperature_K, wavelength_aa, densities_cm3, abundance, dbase_root)
+                   for symbol in elements]
+
+    if n_workers <= 0:
+        n_workers = (len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity")
+                     else os.cpu_count() or 1)
+    if n_workers > 1 and len(worker_args) > 1:
+        import multiprocessing as mp
+
+        with mp.get_context("spawn").Pool(min(n_workers, len(worker_args))) as pool:
+            results = pool.map(_element_continuum, worker_args)
+    else:
+        results = [_element_continuum(args) for args in worker_args]
+
+    free = np.zeros((temperature_K.size, wavelength_aa.size))
+    two_photon = np.zeros((temperature_K.size, densities_cm3.size, wavelength_aa.size))
+    left_out = {ion for *_, ions, _ in results for ion in ions}
+    single_ion = [entry for *_, entries in results for entry in entries]
+    if single_ion:
+        print(f"  CHIANTI's recombination and ionisation rates of each level stop short of "
+              f"the hottest temperatures for {len(single_ion)} ions, whose two-photon "
+              f"emission there is worked out with fiasco's single-ion model, as for ions "
+              f"that have no such rates: {', '.join(single_ion)}")
+    for kind in ("free-bound", "two-photon"):
+        ions = [entry.rsplit(" (", 1)[0] for entry in left_out if entry.endswith(f"({kind})")]
+        if ions:
+            print(f"  CHIANTI has no {kind} data for {len(ions)} ions, which are left out of "
+                  f"that part of the continuum: {_ion_list(ions)}")
+    for symbol, element_free, element_two_photon, used, _, _ in results:
+        if dbase_root is not None and used != dbase_root:
+            raise RuntimeError(
+                f"The continuum of {symbol} was worked out from the CHIANTI database at "
+                f"{used} instead of the requested {dbase_root}.")
+        if not (np.all(np.isfinite(element_free)) and np.all(np.isfinite(element_two_photon))):
+            raise RuntimeError(f"fiasco gave a continuum for {symbol} that is not finite "
+                               f"everywhere.")
+        free += element_free
+        two_photon += element_two_photon
+
+    # Convert fiasco's continuum, per n_e n_H, over all directions and per
+    # Angstrom, to per n_e^2, per steradian and per cm.
+    kwargs = {} if dbase_root is None else {"hdf5_dbase_root": dbase_root}
+    hydrogen = fiasco.Ion("H 1", temperature_K * u.K, abundance=abundance, **kwargs)
+    ratio = np.asarray(hydrogen.proton_electron_ratio.to_value(u.dimensionless_unscaled))
+    per_cm = (1.0 / u.AA).to_value(1.0 / u.cm)
+    scale = ratio / (4.0 * np.pi) * per_cm
+    free = free * scale[:, np.newaxis]
+    two_photon = np.moveaxis(two_photon * scale[:, np.newaxis, np.newaxis], 1, 0)
+    return free, two_photon
+
+
+def continuum_spectra(
+    emission_measure: np.ndarray,
+    electron_density: np.ndarray,
+    logN_grid: np.ndarray,
+    free: np.ndarray,
+    two_photon: np.ndarray,
+) -> np.ndarray:
+    """
+    Continuum spectral radiance in every pixel.
+
+    Parameters
+    ----------
+    emission_measure : np.ndarray
+        Emission measure n_e^2 dh in each temperature bin of each pixel, in
+        cm^-5, shape (rows, columns, nT): a DEM times its bin widths.
+        ECLIPSE's synthesis uses its own DEM, which, unlike `em_tv`, keeps
+        plasma moving faster than the velocity grid reaches.
+    electron_density : np.ndarray or float
+        Electron density in cm^-3 at each pixel and temperature, same shape
+        as `emission_measure`, or one density for all. ECLIPSE's own
+        synthesis gives the mean weighted by emission measure.
+    logN_grid : np.ndarray
+        Densities `two_photon` is tabulated on, as log10(n_e / cm-3).
+    free, two_photon : np.ndarray
+        From `compute_continuum_fiasco`, on the temperatures of the emission
+        measure.
+
+    Returns
+    -------
+    np.ndarray
+        Spectral radiance, shape (rows, columns, n_wavelength), in
+        erg / (s cm2 sr cm). Two-photon emission is interpolated linearly in
+        log10 n_e and is zero at densities off the grid, as for the lines'
+        contribution functions.
+    """
+    em = np.asarray(emission_measure, dtype=float)
+    rows, columns, n_t = em.shape
+    if free.shape[0] != n_t or two_photon.shape[1] != n_t:
+        raise ValueError(f"The emission measure has {n_t} temperatures, but the continuum "
+                         f"has {free.shape[0]}.")
+    density = np.broadcast_to(np.asarray(electron_density, dtype=float), em.shape)
+    flat = em.reshape(-1, n_t)
+    spectra = flat @ free
+    log_n = np.log10(np.where(density > 0, density, np.nan)).reshape(-1, n_t)
+    grid = np.asarray(logN_grid, dtype=float)
+    for t in range(n_t):
+        weight = flat[:, t]
+        lit = (weight > 0) & np.isfinite(log_n[:, t])
+        lit &= (log_n[:, t] >= grid[0]) & (log_n[:, t] <= grid[-1])
+        if not lit.any():
+            continue
+        position = np.interp(log_n[lit, t], grid, np.arange(grid.size, dtype=float))
+        lower = np.floor(position).astype(int)
+        upper = np.minimum(lower + 1, grid.size - 1)
+        fraction = position - lower
+        table = two_photon[:, t, :]
+        spectra[lit] += weight[lit, np.newaxis] * (
+            (1.0 - fraction)[:, np.newaxis] * table[lower] + fraction[:, np.newaxis] * table[upper])
+    return spectra.reshape(rows, columns, -1)
+
+
+def _ion_list(ions: Sequence[str]) -> str:
+    """Ions such as `["Fe 1", "Fe 2", "Fe 27"]` written as `"Fe 1-2, 27"`, element by element."""
+    stages: Dict[str, List[int]] = {}
+    for ion in ions:
+        symbol, stage = ion.split()
+        stages.setdefault(symbol, []).append(int(stage))
+    parts = []
+    from .utils import element_data
+
+    for symbol in sorted(stages, key=lambda s: element_data(s)[0]):
+        numbers = sorted(set(stages[symbol]))
+        runs, start = [], numbers[0]
+        for previous, number in zip(numbers, numbers[1:] + [None]):
+            if number is None or number != previous + 1:
+                runs.append(str(start) if start == previous else f"{start}-{previous}")
+                start = number
+        parts.append(f"{symbol} {', '.join(runs)}")
+    return "; ".join(parts)

eclipse/data/eis_response/EIS_EffArea_A.004

@@ -0,0 +1,61 @@
+# EIS_EFFArea_A.004
+# EIS Effective Area
+# Mon Apr 23 10:40:45 2007
+# Front filter data file: EIS_FFA_A_Trans.003
+# SEF data file: EIS_SEFTrans.002
+# Mirror data file: EIS_MirrorRefl_A.003
+# Grating data file: EIS_GratingRefl_A.003
+# Vignetting data file: EIS_vignetting.001
+# Mirror area:  88.4
+# Groove efficiency: 1.00
+# CCD qe: 0.64
+# Spider trans: 0.80
+# Mesh trans: 1.00
+      245.000    0.0226728
+      246.000    0.0243236
+      247.000    0.0262798
+      248.000    0.0281824
+      249.000    0.0296339
+      250.000    0.0315844
+      251.000    0.0351500
+      252.000    0.0390812
+      253.000    0.0428331
+      254.000    0.0466468
+      255.000    0.0506535
+      256.000    0.0546878
+      257.000    0.0587970
+      258.000    0.0630460
+      259.000    0.0673784
+      260.000    0.0718699
+      261.000    0.0765660
+      262.000    0.0813246
+      263.000    0.0860998
+      264.000    0.0909178
+      265.000    0.0955089
+      266.000    0.0998424
+      267.000     0.103622
+      268.000     0.106984
+      269.000     0.109509
+      270.000     0.110764
+      271.000     0.110875
+      272.000     0.109445
+      273.000     0.106640
+      274.000     0.102602
+      275.000    0.0974887
+      276.000    0.0914836
+      277.000    0.0847751
+      278.000    0.0777747
+      279.000    0.0705505
+      280.000    0.0635321
+      281.000    0.0571789
+      282.000    0.0513891
+      283.000    0.0460830
+      284.000    0.0413185
+      285.000    0.0371190
+      286.000    0.0333321
+      287.000    0.0298378
+      288.000    0.0266719
+      289.000    0.0238613
+      290.000    0.0213016
+      291.000    0.0189506
+      292.000    0.0167953

eclipse/data/eis_response/EIS_EffArea_B.004

@@ -0,0 +1,60 @@
+# EIS_EFFArea_B.004
+# EIS Effective Area
+# Mon Apr 23 10:40:45 2007
+# Front filter data file: EIS_FFA_B_Trans.003
+# SEF data file: EIS_SEFTrans.002
+# Mirror data file: EIS_MirrorRefl_B.003
+# Grating data file: EIS_GratingRefl_B.003
+# Mirror area:  88.4
+# Groove efficiency: 1.00
+# CCD qe: 0.64
+# Spider trans: 0.80
+# Mesh trans: 1.00
+      165.000  0.000174973
+      166.000  0.000232704
+      167.000  0.000248308
+      168.000  0.000241170
+      169.000  0.000265181
+      170.000  0.000379874
+      171.000  0.000255772
+      172.000  0.000621409
+      173.000   0.00109901
+      174.000   0.00140740
+      175.000   0.00184703
+      176.000   0.00275733
+      177.000   0.00436359
+      178.000   0.00677930
+      179.000    0.0100962
+      180.000    0.0146472
+      181.000    0.0209196
+      182.000    0.0296101
+      183.000    0.0412875
+      184.000    0.0562303
+      185.000    0.0740649
+      186.000    0.0945498
+      187.000     0.117659
+      188.000     0.142528
+      189.000     0.168455
+      190.000     0.194897
+      191.000     0.221390
+      192.000     0.246519
+      193.000     0.269192
+      194.000     0.288602
+      195.000     0.301803
+      196.000     0.305428
+      197.000     0.295828
+      198.000     0.269425
+      199.000     0.226404
+      200.000     0.174608
+      201.000     0.124217
+      202.000    0.0838537
+      203.000    0.0570717
+      204.000    0.0416032
+      205.000    0.0325555
+      206.000    0.0267497
+      207.000    0.0224701
+      208.000    0.0189209
+      209.000    0.0157723
+      210.000    0.0131231
+      211.000    0.0110494
+      212.000   0.00951424

eclipse/data/eis_response/EIS_EffArea_B.005

@@ -0,0 +1,64 @@
+# EIS_EFFArea_B.005
+# EIS Effective Area
+# Mon Apr 23 10:40:45 2007
+# Front filter data file: EIS_FFA_B_Trans.003
+# SEF data file: EIS_SEFTrans.002
+# Mirror data file: EIS_MirrorRefl_B.003
+# Grating data file: EIS_GratingRefl_B.003
+# Mirror area:  88.4
+# Groove efficiency: 1.00
+# CCD qe: 0.64
+# Spider trans: 0.80
+# Mesh trans: 1.00
+# Thu Apr 14 08:08:21 EDT 2011
+# Extrapolated [linear extrapolation in log(y)] 
+# one new point at 213 Angstroms (JTM)
+      165.000  0.000174973
+      166.000  0.000232704
+      167.000  0.000248308
+      168.000  0.000241170
+      169.000  0.000265181
+      170.000  0.000379874
+      171.000  0.000255772
+      172.000  0.000621409
+      173.000   0.00109901
+      174.000   0.00140740
+      175.000   0.00184703
+      176.000   0.00275733
+      177.000   0.00436359
+      178.000   0.00677930
+      179.000    0.0100962
+      180.000    0.0146472
+      181.000    0.0209196
+      182.000    0.0296101
+      183.000    0.0412875
+      184.000    0.0562303
+      185.000    0.0740649
+      186.000    0.0945498
+      187.000     0.117659
+      188.000     0.142528
+      189.000     0.168455
+      190.000     0.194897
+      191.000     0.221390
+      192.000     0.246519
+      193.000     0.269192
+      194.000     0.288602
+      195.000     0.301803
+      196.000     0.305428
+      197.000     0.295828
+      198.000     0.269425
+      199.000     0.226404
+      200.000     0.174608
+      201.000     0.124217
+      202.000    0.0838537
+      203.000    0.0570717
+      204.000    0.0416032
+      205.000    0.0325555
+      206.000    0.0267497
+      207.000    0.0224701
+      208.000    0.0189209
+      209.000    0.0157723
+      210.000    0.0131231
+      211.000    0.0110494
+      212.000   0.00951424
+      213.000   0.00819236

eclipse/data/eis_response/README_dz2025

@@ -0,0 +1,50 @@
+
+The files are associated with the paper
+describing the in-flight radiometric calibration of the
+Hinode EIS instrument
+
+see doi: 10.48550/arXiv.2308.06609
+ 
+
+
+The IDL save files contain a structure RETURN_STR with the results of the
+fits of the single spectra, merged.
+
+The main array is return_str.total_counts  which contains the
+total counts in the lines for all the dates, in units of
+DN/s/1arc sec
+
+The array return_str.list_lambda has the expected wavelengths of the lines.
+
+The arrays in data_active_sfit_2023.save
+return_str.eis_sw_ar_spectra and return_str.eis_lw_ar_spectra
+contain the active region averaged spectra. 
+
+The arrays in data_quiet_sfit_2023.save
+return_str.eis_sw_qs_spectra and return_str.eis_lw_qs_spectra
+contain the quiet Sun  averaged spectra. 
+
+The wavelengths can be obtained with
+eis_pixel_to_wavelength(indgen(2048),1,2)
+and
+eis_pixel_to_wavelength(indgen(2048),2,2)
+for the 2 arcsecond slit. 
+
+Note that the spectra have not been wavelength calibrated. 
+
+
+They are the result of the  processing of  a large number of EIS data
+for the in-flight calibration from 2007 to 2022.
+
+
+
+The routine used to process Hinode EIS full spectral raster atlases
+is process_atlas.pro
+
+The routine interpol_eis_ea.pro is to be used together with
+the save file fit_eis_ea_2023-05-04_smooth.sav  to obtain the
+time and wavelength-dependent effective area.
+
+
+ written by Giulio Del Zanna (GDZ), December 15 2023
+

eclipse/data/eis_response/source.txt

@@ -0,0 +1,33 @@
+Hinode/EIS effective-area data, used by eclipse/eis_calibration.py.
+
+EIS_EffArea_A.004  (long-wavelength channel, 245-292 Angstrom)
+EIS_EffArea_B.004  (short-wavelength channel, 165-212 Angstrom)
+EIS_EffArea_B.005  (short-wavelength channel, 165-213 Angstrom)
+
+    Pre-flight ground-calibration effective areas, produced at MSSL in
+    April 2007. Copied verbatim from SolarSoft:
+    $SSW/hinode/eis/response/. IDL eis_ea.pro reads the latest of each,
+    A.004 and B.005, which is B.004 with a point at 213 Angstrom added;
+    eis_ltds.pro names A.004 and B.004. Column 1 is wavelength in Angstrom,
+    column 2 is effective area in cm^2 with the CCD quantum efficiency
+    already included.
+
+    Lang, J. et al. 2006, Applied Optics, 45, 8689
+    EIS Software Note 2, "Radiometric Calibration".
+
+fit_eis_ea_2023-05-04_smooth.sav
+
+    Fitted time- and wavelength-dependent effective areas from the Del
+    Zanna et al. (2025) in-flight radiometric calibration, covering 2007
+    to 2022. interpol_eis_ea.pro reads the unsmoothed
+    fit_eis_ea_2023-05-04.sav unless given another; this is the smoothed
+    one, which the accompanying README_dz2025 (kept alongside it here,
+    verbatim) says to use. Distributed by Giulio Del Zanna.
+
+    doi: 10.48550/arXiv.2308.06609
+
+The Del Zanna (2013) spline points and the Warren et al. (2014) exponential
+decay coefficients are small enough to live in the source rather than in a
+data file; their provenance is recorded in eis_calibration.py.
+
+13/08/2026, B.005 added 28/09/2026