solarc-eclipse 0.6.2__tar.gz → 0.8.0__tar.gz

solarc_eclipse-0.8.0/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) James McKevitt
+
+Publishing any results produced by this software, or any work derived from it, requires permission from the author. Contact James McKevitt (jm2@mssl.ucl.ac.uk) before publication.
+
+The SOLAR-C SWG are also required to approve the publication of forward modelling results for SOLAR-C/EUVST. Contact James McKevitt (jm2@mssl.ucl.ac.uk) for more information.

solarc_eclipse-0.8.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: solarc-eclipse
+Version: 0.8.0
+Summary: ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
+Home-page: https://github.com/jamesmckevitt/eclipse
+Author: James McKevitt
+Author-email: James McKevitt <jm2@mssl.ucl.ac.uk>
+License: Copyright (c) James McKevitt
+        
+        Publishing any results produced by this software, or any work derived from it, requires permission from the author. Contact James McKevitt (jm2@mssl.ucl.ac.uk) before publication.
+        
+        The SOLAR-C SWG are also required to approve the publication of forward modelling results for SOLAR-C/EUVST. Contact James McKevitt (jm2@mssl.ucl.ac.uk) for more information.
+Project-URL: Homepage, https://github.com/jamesmckevitt/eclipse
+Project-URL: Repository, https://github.com/jamesmckevitt/eclipse
+Project-URL: Documentation, https://solarc-eclipse.readthedocs.io
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: astropy
+Requires-Dist: ndcube
+Requires-Dist: specutils
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: joblib
+Requires-Dist: tqdm
+Requires-Dist: dill
+Requires-Dist: pyyaml
+Requires-Dist: reproject
+Requires-Dist: sunpy[all]
+Requires-Dist: dask
+Requires-Dist: psutil
+Requires-Dist: mendeleev
+Requires-Dist: h5py
+Requires-Dist: fiasco
+Provides-Extra: mpi
+Requires-Dist: mpi4py; extra == "mpi"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ipywidgets; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Requires-Dist: mkdocs-jupyter; extra == "docs"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
+
+The ECLIPSE code (Emission Calculation and Line Prediction for SOLAR-C EUVST) is used to forward model the performance of the EUV spectrograph EUVST onboard the SOLAR-C spacecraft.
+
+Contact: James McKevitt (jm2@mssl.ucl.ac.uk). See [LICENSE](LICENSE) for usage terms.
+
+The instrument response generated by this code will be updated during instrument development, testing, and commissioning.
+
+[![Documentation Status](https://readthedocs.org/projects/solarc-eclipse/badge/?version=latest)](https://solarc-eclipse.readthedocs.io/en/latest/)
+[![PyPI](https://img.shields.io/pypi/v/solarc-eclipse.svg)](https://pypi.org/project/solarc-eclipse/)
+[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.17543844-blue.svg)](https://doi.org/10.5281/zenodo.17543844)
+
+Full documentation - installation, quick start, the synthesis and instrument response guides, and the analysis tutorial - is at **[solarc-eclipse.readthedocs.io](https://solarc-eclipse.readthedocs.io)**.
+
+## Acknowledgements
+
+The SOLAR-C/EUVST-SW instrument is an ESA-funded contribution to the JAXA-led SOLAR-C mission. The EUVST-LW (long wavelength) instrument is contributed by NASA. The ECLIPSE code is developed and maintained at Mullard Space Science Laboratory (UCL), and was made using Austrian Super Computing (ASC) infrastructure in collaboration with the University of Vienna.

solarc_eclipse-0.8.0/README.md

@@ -0,0 +1,17 @@
+# ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
+
+The ECLIPSE code (Emission Calculation and Line Prediction for SOLAR-C EUVST) is used to forward model the performance of the EUV spectrograph EUVST onboard the SOLAR-C spacecraft.
+
+Contact: James McKevitt (jm2@mssl.ucl.ac.uk). See [LICENSE](LICENSE) for usage terms.
+
+The instrument response generated by this code will be updated during instrument development, testing, and commissioning.
+
+[![Documentation Status](https://readthedocs.org/projects/solarc-eclipse/badge/?version=latest)](https://solarc-eclipse.readthedocs.io/en/latest/)
+[![PyPI](https://img.shields.io/pypi/v/solarc-eclipse.svg)](https://pypi.org/project/solarc-eclipse/)
+[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.17543844-blue.svg)](https://doi.org/10.5281/zenodo.17543844)
+
+Full documentation - installation, quick start, the synthesis and instrument response guides, and the analysis tutorial - is at **[solarc-eclipse.readthedocs.io](https://solarc-eclipse.readthedocs.io)**.
+
+## Acknowledgements
+
+The SOLAR-C/EUVST-SW instrument is an ESA-funded contribution to the JAXA-led SOLAR-C mission. The EUVST-LW (long wavelength) instrument is contributed by NASA. The ECLIPSE code is developed and maintained at Mullard Space Science Laboratory (UCL), and was made using Austrian Super Computing (ASC) infrastructure in collaboration with the University of Vienna.

{solarc_eclipse-0.6.2 → solarc_eclipse-0.8.0}/euvst_response/__init__.py

@@ -4,7 +4,7 @@ ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
 This package provides tools for modeling the performance of the EUV spectrograph EUVST, on SOLAR-C.
 """
 
-__version__ = "0.6.2"
+__version__ = "0.8.0"
 __author__ = "James McKevitt"
 __email__ = "jm2@mssl.ucl.ac.uk"
 
@@ -13,11 +13,11 @@ from .config import Detector_SWC, Detector_EIS, Telescope_EUVST, Telescope_EIS,
 from .utils import wl_to_vel, vel_to_wl, angle_to_distance, distance_to_angle
 from .radiometric import (
     intensity_to_photons, add_telescope_throughput, photons_to_pixel_counts,
-    apply_exposure_and_poisson, add_poisson, apply_focusing_optics_psf, to_electrons, 
+    apply_exposure, sample_photon_arrivals, add_poisson, apply_focusing_optics_psf, to_electrons, 
     to_dn, add_visible_stray_light, add_pinhole_visible_light
 )
 from .pinhole_diffraction import apply_euv_pinhole_diffraction, airy_disk_pattern
-from .fitting import fit_cube_gauss, velocity_from_fit, width_from_fit, analyse
+from .fitting import fit_cube_gauss, velocity_from_fit, width_from_fit, analyse, FitConfig, FitComponent
 from .monte_carlo import simulate_once, monte_carlo
 from .main import main
 from .data_processing import load_atmosphere, create_uniform_intensity_cube
@@ -36,9 +36,10 @@ __all__ = [
     "Simulation", "AluminiumFilter",
     "wl_to_vel", "vel_to_wl", "angle_to_distance", "distance_to_angle",
     "intensity_to_photons", "add_telescope_throughput", "photons_to_pixel_counts",
-    "apply_exposure_and_poisson", "add_poisson", "apply_focusing_optics_psf", "to_electrons", 
+    "apply_exposure", "sample_photon_arrivals", "add_poisson", "apply_focusing_optics_psf", "to_electrons", 
     "to_dn", "add_visible_stray_light", "add_pinhole_visible_light",
     "fit_cube_gauss", "velocity_from_fit", "width_from_fit", "analyse",
+    "FitConfig", "FitComponent",
     "simulate_once", "monte_carlo",
     "main",
     "load_atmosphere",

{solarc_eclipse-0.6.2 → solarc_eclipse-0.8.0}/euvst_response/analysis.py

@@ -119,7 +119,8 @@ def get_parameter_combinations(results: Dict[str, Any]) -> List[Dict]:
 def analyse_fit_statistics(
     combination_results: Dict[str, Any],
     rest_wavelength: u.Quantity,
-    data_type: str = "dn"
+    data_type: str = "dn",
+    fit_config=None,
 ) -> Dict[str, Any]:
     """
     Analyze fit statistics to compute velocity and line width statistics.
@@ -132,35 +133,52 @@ def analyse_fit_statistics(
         Rest wavelength for velocity conversion.
     data_type : str, optional
         Either "dn" or "photon" to specify which fit statistics to analyze.
+    fit_config : FitConfig, optional
+        Multi-component fitting configuration. When provided the primary-
+        component indices are used; otherwise indices 1 (centre) and
+        2 (sigma) are assumed (single-component default).
         
     Returns
     -------
     dict
         Dictionary containing velocity and width statistics.
     """
+    # Determine parameter indices for the primary component
+    if fit_config is not None and not fit_config.is_single:
+        idx_center = fit_config.idx_center
+        idx_sigma = fit_config.idx_sigma
+    else:
+        idx_center = 1
+        idx_sigma = 2
+
     # Get fit statistics
     fit_stats_key = f"{data_type}_fit_stats"
     if fit_stats_key not in combination_results:
         raise ValueError(f"No {fit_stats_key} found in combination results")
     
     fit_stats = combination_results[fit_stats_key]
+    if fit_stats is None:
+        raise ValueError(
+            f"'{data_type}' signal was not fitted for this combination. "
+            f"Check the 'fit_signals' setting in your YAML config."
+        )
     fit_truth_data = combination_results["ground_truth"]["fit_truth_data"]
     fit_truth_units = combination_results["ground_truth"]["fit_truth_units"]
     
     # Extract data and units
-    mean_data = fit_stats["mean_data"]      # Shape: (nx, ny, 4)
-    std_data = fit_stats["std_data"]        # Shape: (nx, ny, 4)
-    units = fit_stats["units"]              # List of 4 astropy units
+    mean_data = fit_stats["mean_data"]      # Shape: (nx, ny, n_params)
+    std_data = fit_stats["std_data"]        # Shape: (nx, ny, n_params)
+    units = fit_stats["units"]              # List of n_params astropy units
     
-    # Get center statistics (parameter index 1)
-    center_mean_data = mean_data[..., 1]    # (nx, ny) - values only
-    center_std_data = std_data[..., 1]      # (nx, ny) - values only
-    center_unit = units[1]                  # wavelength unit
+    # Get center statistics for the primary component
+    center_mean_data = mean_data[..., idx_center]
+    center_std_data = std_data[..., idx_center]
+    center_unit = units[idx_center]
     
-    # Get width statistics (parameter index 2)
-    width_mean_data = mean_data[..., 2]     # (nx, ny) - values only
-    width_std_data = std_data[..., 2]       # (nx, ny) - values only
-    width_unit = units[2]                   # wavelength unit
+    # Get width statistics for the primary component
+    width_mean_data = mean_data[..., idx_sigma]
+    width_std_data = std_data[..., idx_sigma]
+    width_unit = units[idx_sigma]
     
     # Create quantities
     center_mean_q = center_mean_data * center_unit
@@ -177,7 +195,7 @@ def analyse_fit_statistics(
     
     # Convert to velocities
     v_mean = centers_to_velocity(center_mean_q, rest_wavelength)
-    v_true = centers_to_velocity(fit_truth_data[..., 1] * fit_truth_units[1], rest_wavelength)
+    v_true = centers_to_velocity(fit_truth_data[..., idx_center] * fit_truth_units[idx_center], rest_wavelength)
     v_err = v_true - v_mean
     
     # Convert center std to velocity std using differential: dv/dlambda = c/lambda
@@ -377,11 +395,12 @@ def summary_table(results: Dict[str, Any]) -> None:
 
 def create_sunpy_maps_from_combo(
     combination_results: Dict[str, Any],
-    cube_reb,
+    cube_reb=None,
     rest_wavelength: u.Quantity = 195.119 * u.AA,
     data_type: str = "dn",
     precision_requirement: u.Quantity = 2.0 * u.km / u.s,
-    exposure_time_results: List[Dict[str, Any]] | None = None
+    exposure_time_results: List[Dict[str, Any]] | None = None,
+    fit_config=None,
 ) -> Dict[str, Any]:
     """
     Create SunPy maps from combination results using the new fit statistics structure.
@@ -390,8 +409,9 @@ def create_sunpy_maps_from_combo(
     ----------
     combination_results : dict
         Results for a specific parameter combination from get_results_for_combination().
-    cube_reb : NDCube
+    cube_reb : NDCube, optional
         NDCube with helioprojective WCS to use for all maps.
+        If not provided, the WCS stored in the combination results is used.
     rest_wavelength : u.Quantity, optional
         Rest wavelength for velocity conversion (default: 195.119 A for Fe XII).
     data_type : str, optional
@@ -401,6 +421,9 @@ def create_sunpy_maps_from_combo(
     exposure_time_results : list of dict, optional
         List of results from get_results_for_combination() for different exposure times.
         If provided, will create an exposure time map showing minimum exposure needed.
+    fit_config : FitConfig, optional
+        Multi-component fitting configuration. When provided, the primary-
+        component indices are used to extract centre and width parameters.
         
     Returns
     -------
@@ -426,19 +449,27 @@ def create_sunpy_maps_from_combo(
             # Extract exposure time from parameters
             exposure_time = result["parameters"]["simulation.expos"].to_value(u.s)
             # Create analysis for this exposure
-            analysis = analyse_fit_statistics(result, rest_wavelength, data_type)
+            analysis = analyse_fit_statistics(result, rest_wavelength, data_type, fit_config=fit_config)
             analysis_per_exp[exposure_time] = analysis
     else:
         analysis_per_exp = None
     
-    # Extract 2D helioprojective WCS from the cube
-    wcs_2d = cube_reb.wcs.celestial.swapaxes(0, 1)
+    # Extract 2D helioprojective WCS from the cube or stored signal WCS
+    if cube_reb is not None:
+        wcs_2d = cube_reb.wcs.celestial.swapaxes(0, 1)
+    else:
+        wcs_2d = combination_results["first_signal_wcs"].celestial.swapaxes(0, 1)
     
     # Get the data arrays - now only first iteration is saved
     first_photon_signal = combination_results["first_photon_signal"]  # Shape: (nx, ny, nwave)
     first_dn_signal = combination_results["first_dn_signal"]         # Shape: (nx, ny, nwave)
     fit_stats_key = f"{data_type}_fit_stats"
     fit_stats = combination_results[fit_stats_key]          # Contains first_fit_data, mean_data, std_data, units
+    if fit_stats is None:
+        raise ValueError(
+            f"'{data_type}' signal was not fitted for this combination. "
+            f"Check the 'fit_signals' setting in your YAML config."
+        )
     
     maps = {}
 
@@ -457,14 +488,22 @@ def create_sunpy_maps_from_combo(
     maps['total_dn'] = sunpy.map.Map(total_dn_data.T, wcs_2d)
     maps['total_dn'].meta['bunit'] = str(total_dn_unit)
     
+    # Determine parameter indices for the primary component
+    if fit_config is not None and not fit_config.is_single:
+        idx_center = fit_config.idx_center
+        idx_sigma = fit_config.idx_sigma
+    else:
+        idx_center = 1
+        idx_sigma = 2
+
     # --- Get velocity and width analysis for this combination ---
-    analysis = analyse_fit_statistics(combination_results, rest_wavelength, data_type)
+    analysis = analyse_fit_statistics(combination_results, rest_wavelength, data_type, fit_config=fit_config)
 
     # --- Velocity maps ---
-    # Velocity from first fit (parameter 1 = center)
-    first_fit_data = fit_stats["first_fit_data"]  # Shape: (nx, ny, 4)
-    center_first_data = first_fit_data[..., 1]    # Extract center parameter
-    center_first_unit = fit_stats["units"][1]     # Get units for center parameter
+    # Velocity from first fit (primary component center)
+    first_fit_data = fit_stats["first_fit_data"]  # Shape: (nx, ny, n_params)
+    center_first_data = first_fit_data[..., idx_center]
+    center_first_unit = fit_stats["units"][idx_center]
 
     def centers_to_velocity(centers_data, centers_unit, lambda0):
         """Convert wavelength centers to velocities"""
@@ -492,9 +531,9 @@ def create_sunpy_maps_from_combo(
     maps['velocity_err'].meta['bunit'] = str(analysis["v_err"].unit)
 
     # --- Line width maps ---
-    # Line width from first fit (parameter 2 = width)
-    width_first_data = first_fit_data[..., 2]     # Extract width parameter data
-    width_first_unit = fit_stats["units"][2]      # Get units for width parameter
+    # Line width from first fit (primary component sigma)
+    width_first_data = first_fit_data[..., idx_sigma]
+    width_first_unit = fit_stats["units"][idx_sigma]
 
     # Create quantity with proper units
     width_quantity = width_first_data * width_first_unit

{solarc_eclipse-0.6.2 → solarc_eclipse-0.8.0}/euvst_response/data_processing.py

@@ -14,7 +14,18 @@ from specutils import Spectrum
 from specutils.manipulation import FluxConservingResampler
 from joblib import Parallel, delayed
 from tqdm import tqdm
-from .utils import tqdm_joblib, distance_to_angle
+from .utils import tqdm_joblib, distance_to_angle, _fwhm_to_sigma
+
+
+def _resample_batch(flat_chunk, unit, spectral_world, new_spec_grid, n_spec):
+    """Resample a chunk of pixels (module-level for efficient pickling)."""
+    resampler = FluxConservingResampler(extrapolation_treatment="zero_fill")
+    batch_results = np.empty((flat_chunk.shape[0], n_spec))
+    for i in range(flat_chunk.shape[0]):
+        spec = Spectrum(flux=flat_chunk[i] * unit, spectral_axis=spectral_world)
+        res = resampler(spec, new_spec_grid)
+        batch_results[i] = res.flux.value
+    return batch_results
 
 
 def load_atmosphere(pkl_file: str, metadata_line: str = None) -> tuple:
@@ -171,19 +182,15 @@ def resample_ndcube_spectral_axis(ndcube, spectral_axis, output_resolution, ncpu
     # Create batch indices
     batch_indices = [(i, min(i + batch_size, n_pixels)) for i in range(0, n_pixels, batch_size)]
 
-    def _resample_batch(start_idx, end_idx):
-        """Resample a batch of pixels."""
-        resampler = FluxConservingResampler(extrapolation_treatment="zero_fill")
-        batch_results = np.empty((end_idx - start_idx, n_spec))
-        for i, pixel_idx in enumerate(range(start_idx, end_idx)):
-            spec = Spectrum(flux=flat_data[pixel_idx] * ndcube.unit, spectral_axis=spectral_world)
-            res = resampler(spec, new_spec_grid)
-            batch_results[i] = res.flux.value
-        return batch_results
+    # Pass .copy() slices so loky pickles only the small chunk, not the full array
+    unit = ndcube.unit
 
     with tqdm_joblib(tqdm(total=len(batch_indices), desc="Resampling spectral axis", unit="batch", leave=False)):
         results = Parallel(n_jobs=ncpu)(
-            delayed(_resample_batch)(start, end) for start, end in batch_indices
+            delayed(_resample_batch)(
+                flat_data[start:end].copy(), unit, spectral_world, new_spec_grid, n_spec
+            )
+            for start, end in batch_indices
         )
     resampled = np.vstack(results)
 
@@ -324,9 +331,11 @@ def create_uniform_intensity_cube(
     det,
     sim,
     n_sigma_extent: float = 8.0,
+    n_slit_pixels: int = 1,
+    tel=None,
 ) -> NDCube:
     """
-    Create a 1x1 pixel NDCube containing a Gaussian emission line.
+    Create a 1 x ``n_slit_pixels`` pixel NDCube containing a Gaussian emission line.
 
     The cube is built directly at the detector's spectral resolution and
     assigned a helioprojective WCS consistent with the output of
@@ -347,14 +356,30 @@ def create_uniform_intensity_cube(
         Simulation configuration (provides ``slit_width``).
     n_sigma_extent : float, optional
         Number of sigma either side of line centre to include in the
-        wavelength grid (default: 8).
+        wavelength grid (default: 8).  Measured on the width the line will have
+        once the spectral PSF has been applied, if *tel* is given.
+    n_slit_pixels : int, optional
+        Number of (uniform) slit pixels to generate.  Set to the
+        ``offchip_bin_slit`` value so that subsequent ``rebin_slit_offchip``
+        sums ``n_slit_pixels`` independent noise realisations into a single
+        binned pixel (default: 1).
+    tel : Telescope_EUVST or Telescope_EIS, optional
+        Telescope configuration.  When given, the grid is widened to hold the
+        line after spectral PSF broadening, adding the PSF width to the thermal
+        width in quadrature.  Without this a narrow line gets a grid only a
+        couple of pixels wide, and convolving it with a PSF wider than the line
+        pushes flux off the ends of the grid.  Default None, which sizes the
+        grid on the thermal width alone.
 
     Returns
     -------
     NDCube
-        Shape ``(1, 1, n_lambda)`` with unit ``erg / (s cm2 sr cm)`` and a
+        Shape ``(1, n_slit_pixels, n_lambda)`` with unit ``erg / (s cm2 sr cm)`` and a
         helioprojective + wavelength WCS.
     """
+    if n_slit_pixels < 1:
+        raise ValueError(f"n_slit_pixels must be >= 1, got {n_slit_pixels}")
+
     # --- Spectral grid --------------------------------------------------
     lam0 = rest_wavelength.to(u.cm)
 
@@ -364,7 +389,19 @@ def create_uniform_intensity_cube(
     # Detector pixel pitch in cm
     dlam = det.wvl_res.to(u.cm / u.pix) * u.pix  # strip per-pixel to cm
 
-    half_range = n_sigma_extent * sigma_lam
+    # The grid has to hold the line as it will be *measured*, not as it leaves
+    # the Sun, so add the spectral PSF to the thermal width in quadrature.
+    # Widths add that way for Gaussians, and the PSF is often the broader of
+    # the two: at the default 20 km/s the line is 0.77 pixels against a PSF of
+    # 1.08.  Always widening, rather than only when psf is set, keeps the grid
+    # independent of a value that is swept and is not known when the cube is
+    # built and cached.
+    sigma_total = sigma_lam
+    if tel is not None:
+        sigma_psf = _fwhm_to_sigma(tel.psf_params[1].to(u.pixel).value) * dlam
+        sigma_total = np.sqrt(sigma_lam**2 + sigma_psf**2)
+
+    half_range = n_sigma_extent * sigma_total
     n_pix_half = int(np.ceil((half_range / dlam).decompose().value))
     n_lam = 2 * n_pix_half + 1  # always odd, centred on rest wavelength
 
@@ -377,14 +414,17 @@ def create_uniform_intensity_cube(
         u.erg / (u.s * u.cm**2 * u.sr * u.cm)
     )
     profile = A * np.exp(-0.5 * ((lam_grid - lam0) / sigma_lam) ** 2)
-    data = profile.value[np.newaxis, np.newaxis, :]  # shape (1, 1, n_lam)
+    # Tile the profile along the slit axis.  Every slit pixel holds the same
+    # intensity, but each is noised independently downstream, which is what
+    # rebin_slit_offchip needs in order to sum them.
+    data = np.tile(profile.value, (1, n_slit_pixels, 1))  # shape (1, n_slit_pixels, n_lam)
 
     # --- WCS (matches reproject_ndcube output format) --------------------
     # Axes: WAVE (cm), HPLT-TAN (arcsec), HPLN-TAN (arcsec)
     wcs = WCS(naxis=3)
     wcs.wcs.ctype = ["WAVE", "HPLT-TAN", "HPLN-TAN"]
     wcs.wcs.cunit = ["cm", "arcsec", "arcsec"]
-    wcs.wcs.crpix = [(n_lam + 1) / 2, 1.0, 1.0]
+    wcs.wcs.crpix = [(n_lam + 1) / 2, (n_slit_pixels + 1) / 2, 1.0]
     wcs.wcs.crval = [lam0.value, 0.0, 0.0]
     wcs.wcs.cdelt = [
         dlam.to_value(u.cm),