solarc-eclipse 0.5.0__py3-none-any.whl

euvst_response/synthesis_cli.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""
+Command line interface for synthesis script.
+"""
+
+def main():
+    """Entry point for the synthesis command line script."""
+    from .synthesis import main as run_synthesis
+    run_synthesis()
+
+if __name__ == "__main__":
+    main()

euvst_response/utils.py

@@ -0,0 +1,176 @@
+"""
+Utility functions for coordinate transformations, unit conversions, and general helpers.
+"""
+
+from __future__ import annotations
+import contextlib
+from pathlib import Path
+import numpy as np
+import astropy.units as u
+import astropy.constants as const
+import joblib
+from tqdm import tqdm
+
+
+# Global debug flag - can be set by command line or configuration
+DEBUG_MODE = False
+
+
+def set_debug_mode(enabled: bool):
+    """Set global debug mode."""
+    global DEBUG_MODE
+    DEBUG_MODE = enabled
+
+
+def debug_break(message: str = "Debug break triggered", locals_dict=None, globals_dict=None):
+    """
+    Break into IPython debugger if debug mode is enabled.
+    
+    Usage:
+        debug_break("Check values here", locals(), globals())
+    or:
+        debug_break("Error occurred")
+    """
+    if not DEBUG_MODE:
+        return
+        
+    print(f"\n=== DEBUG BREAK: {message} ===")
+    
+    try:
+        # Try to import and start IPython
+        from IPython import embed
+        
+        # Prepare namespace for IPython
+        user_ns = {}
+        if locals_dict:
+            user_ns.update(locals_dict)
+        if globals_dict:
+            user_ns.update(globals_dict)
+            
+        print("Starting IPython session...")
+        print("Available variables:", list(user_ns.keys()) if user_ns else "None provided")
+        print("Type 'exit()' or Ctrl+D to continue execution")
+        
+        # Start IPython with the provided namespace
+        embed(user_ns=user_ns)
+        
+    except ImportError:
+        print("IPython not available. Using standard Python debugger...")
+        import pdb
+        pdb.set_trace()
+
+
+def debug_on_error(func):
+    """
+    Decorator to automatically break into debugger on exceptions when debug mode is enabled.
+    
+    Usage:
+        @debug_on_error
+        def my_function():
+            # your code here
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            if DEBUG_MODE:
+                print(f"\n=== EXCEPTION IN {func.__name__}: {e} ===")
+                # Get the frame where the exception occurred
+                import sys
+                frame = sys.exc_info()[2].tb_frame
+                debug_break(f"Exception in {func.__name__}: {e}", frame.f_locals, frame.f_globals)
+            raise
+    return wrapper
+
+
+def wl_to_vel(wl: u.Quantity, wl0: u.Quantity) -> u.Quantity:
+    """Convert wavelength to line-of-sight velocity."""
+    return (wl - wl0) / wl0 * const.c
+
+
+def vel_to_wl(v: u.Quantity, wl0: u.Quantity) -> u.Quantity:
+    """Convert line-of-sight velocity to wavelength."""
+    return wl0 * (1 + v / const.c)
+
+
+def gaussian(wave, peak, centre, sigma, back):
+    """Gaussian function for spectral line fitting."""
+    return peak * np.exp(-0.5 * ((wave - centre) / sigma) ** 2) + back
+
+
+def angle_to_distance(angle: u.Quantity) -> u.Quantity:
+    """Convert angular size to linear distance at 1 AU."""
+    if angle.unit.physical_type != "angle":
+        raise ValueError("Input must be an angle")
+    return 2 * const.au * np.tan(angle.to(u.rad) / 2)
+
+
+def distance_to_angle(distance: u.Quantity) -> u.Quantity:
+    """Convert linear distance to angular size at 1 AU."""
+    if distance.unit.physical_type != "length":
+        raise ValueError("Input must be a length")
+    return (2 * np.arctan(distance / (2 * const.au))).to(u.arcsec)
+
+
+def parse_yaml_input(val):
+    """Parse YAML input values - handle both single values and lists."""
+    if isinstance(val, str):
+        return u.Quantity(val)
+    elif isinstance(val, (list, tuple)):
+        # Handle list of values
+        if all(isinstance(v, str) for v in val):
+            return [u.Quantity(v) for v in val]
+        else:
+            return list(val)
+    else:
+        return val
+
+
+def ensure_list(val):
+    """Ensure input is a list (for parameter sweeps)."""
+    if not isinstance(val, (list, tuple)):
+        return [val]
+    return list(val)
+
+
+def save_maps(path: str | Path, log_intensity: np.ndarray, v_map: u.Quantity,
+              x_pix_size: float, y_pix_size: float) -> None:
+    """Save intensity and velocity maps for later comparison."""
+    np.savez(
+        path,
+        log_si=log_intensity,
+        v_map=v_map.to(u.km / u.s).value,
+        x_pix_size=x_pix_size,
+        y_pix_size=y_pix_size,
+    )
+
+
+def load_maps(path: str | Path) -> dict:
+    """Load previously saved intensity and velocity maps."""
+    dat = np.load(path)
+    return dict(
+        log_si=dat["log_si"],
+        v_map=dat["v_map"],
+        x_pix_size=float(dat["x_pix_size"]),
+        y_pix_size=float(dat["y_pix_size"]),
+    )
+
+
+@contextlib.contextmanager
+def tqdm_joblib(tqdm_object):
+    """
+    Context manager that patches joblib so it uses the supplied tqdm
+    instance to report progress.
+    """
+    class TqdmBatchCompletionCallback(joblib.parallel.BatchCompletionCallBack):  # type: ignore[attr-defined]
+        def __call__(self, *args, **kwargs):
+            tqdm_object.update(n=self.batch_size)
+            return super().__call__(*args, **kwargs)
+
+    old_callback = joblib.parallel.BatchCompletionCallBack  # type: ignore[attr-defined]
+    joblib.parallel.BatchCompletionCallBack = TqdmBatchCompletionCallback
+    try:
+        yield
+    finally:
+        joblib.parallel.BatchCompletionCallBack = old_callback
+        tqdm_object.close()

solarc_eclipse-0.5.0.dist-info/METADATA

@@ -0,0 +1,354 @@
+Metadata-Version: 2.4
+Name: solarc-eclipse
+Version: 0.5.0
+Summary: ECLIPSE: Emission Calculation and Line Intensity 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: Contact for permission
+Project-URL: Homepage, https://github.com/jamesmckevitt/eclipse
+Project-URL: Repository, https://github.com/jamesmckevitt/eclipse
+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.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+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]
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# ECLIPSE: Emission Calculation and Line Intensity Prediction for SOLAR-C EUVST
+
+The ECLIPSE code (Emission Calculation and Line Intensity Prediction for SOLAR-C EUVST) is used to forward model the performance of the EUV spectrograph EUVST, on SOLAR-C.
+
+Contact: James McKevitt (jm2@mssl.ucl.ac.uk). License: Contact for permission to use.
+
+The instrument response generated by this code will be updated during instrument development, testing, and commissioning.
+
+## Installation
+
+### From PyPI (recommended)
+
+```bash
+pip install solarc-eclipse
+```
+
+### From source
+
+```bash
+git clone https://github.com/jamesmckevitt/eclipse.git
+pip install eclipse
+```
+
+## Quick Start
+
+### Command Line Interface
+
+After installation, you can run ECLIPSE from the command line:
+
+```bash
+# Run synthesis script (convert 3D MHD data to synthetic spectra)
+synthesise-spectra --data-dir ./data/atmosphere --goft-file ./data/gofnt.sav --output-dir ./run/input
+
+# Run instrument response simulation
+eclipse --config ./run/input/config.yaml
+
+# Help can be accessed with
+synthesise-spectra --help
+eclipse --help
+```
+
+### Python API
+
+You can also use ECLIPSE as a Python library:
+
+```python
+import euvst_response
+from euvst_response import AluminiumFilter, Detector_SWC, Telescope_EUVST
+
+telescope = Telescope_EUVST()
+detector = Detector_SWC()
+
+print(f"Telescope collecting area: {telescope.collecting_area:.4f}")
+print(f"Detector QE (EUV): {detector.qe_euv:.2f}")
+
+# Calculate effective area at Fe XII 195.119 Å
+fe12_wl = 195.119 * u.AA
+effective_area = telescope.collecting_area * telescope.throughput(fe12_wl) * detector.qe_euv
+
+# Get breakdown of throughput by component
+pm_eff = telescope.primary_mirror_efficiency(fe12_wl)
+grating_eff = telescope.grating_efficiency(fe12_wl)
+micro_eff = telescope.microroughness_efficiency(fe12_wl)
+filter_eff = telescope.filter.total_throughput(fe12_wl)
+```
+
+### Analysis Tutorial
+
+For analyzing simulation results, see the included Jupyter notebook `analysis_tutorial.ipynb` which demonstrates how to:
+
+- Load simulation results
+- Explore parameter combinations
+- Analyze fit statistics and compute velocity/line width errors
+- Create SunPy maps for visualization
+
+The analysis functions are now available directly from the package:
+
+```python
+from euvst_response import (
+    load_instrument_response_results,
+    get_results_for_combination,
+    analyse_fit_statistics,
+    create_sunpy_maps_from_combo,
+    summary_table
+)
+```
+
+## Detailed instructions
+
+### 1. Generate contribution functions for the desired emission lines
+
+Edit `make_gofnt.pro` to specify the desired emission lines and the location of the CHIANTI files. You can use CHIANTI to identify the required lines.
+
+Run the following command:
+```bash
+idl -e "make_goft"
+```
+
+### 2. Run the line synthesis
+
+The synthesis script converts 3D MHD simulation data into synthetic solar spectra. It can be run directly from the command line with extensive configuration options.
+
+#### Basic Usage
+
+```bash
+# Example using all available command line options
+synthesise-spectra \
+  --data-dir ./data/atmosphere \
+  --goft-file ./data/gofnt.sav \
+  --output-dir ./run/input \
+  --output-name synthesised_spectra.pkl \
+  --temp-file temp/eosT.0270000 \
+  --rho-file rho/result_prim_0.0270000 \
+  --vx-file vx/result_prim_1.0270000 \
+  --vy-file vy/result_prim_3.0270000 \
+  --vz-file vz/result_prim_2.0270000 \
+  --cube-shape 512 768 256 \
+  --voxel-dx 0.192 \
+  --voxel-dy 0.192 \
+  --voxel-dz 0.064 \
+  --vel-res 5.0 \
+  --vel-lim 300.0 \
+  --integration-axis z \
+  --crop-x -50 50 \
+  --crop-y -50 50 \
+  --crop-z 0 20 \
+  --downsample 1 \
+  --precision float64 \
+  --mean-mol-wt 1.29 \
+  --limit-lines Fe12_195.1190
+
+# Show all available options
+synthesise-spectra --help
+```
+
+#### Command Line Options
+
+**Input/Output Paths:**
+- `--data-dir`: Directory containing simulation data (default: `data/atmosphere`)
+- `--goft-file`: Path to CHIANTI G(T,N) save file (default: `./data/gofnt.sav`)
+- `--output-dir`: Output directory for results (default: `./run/input`)
+- `--output-name`: Output filename (default: `synthesised_spectra.pkl`)
+
+**Simulation Files:**
+- `--temp-file`: Temperature file relative to data-dir (default: `temp/eosT.0270000`)
+- `--rho-file`: Density file relative to data-dir (default: `rho/result_prim_0.0270000`)
+- `--vx-file`: X-velocity file (required if `--integration-axis x`)
+- `--vy-file`: Y-velocity file (required if `--integration-axis y`)
+- `--vz-file`: Z-velocity file (required if `--integration-axis z`)
+
+**Grid Parameters:**
+- `--cube-shape`: Cube dimensions as three integers (default: `512 768 256`)
+- `--voxel-dx`, `--voxel-dy`, `--voxel-dz`: Voxel sizes in Mm (default: `0.192 0.192 0.064`)
+
+**Velocity Grid:**
+- `--vel-res`: Velocity resolution in km/s (default: `5.0`)
+- `--vel-lim`: Velocity limit ±km/s (default: `300.0`)
+
+**Integration and Viewing:**
+- `--integration-axis`: Integration axis: `x`, `y`, or `z` (default: `z`)
+  - `z`: Standard top-down view (integrates through height)
+  - `x`: Side view from the left (integrates left-to-right)
+  - `y`: Side view from the front (integrates front-to-back)
+
+**Spatial Cropping (Heliocentric coordinates in Mm):**
+- `--crop-x`: X-range to crop, e.g., `--crop-x -50 50` (optional)
+- `--crop-y`: Y-range to crop, e.g., `--crop-y -50 50` (optional)  
+- `--crop-z`: Z-range to crop, e.g., `--crop-z 0 20` (optional)
+- Omit any crop option to use the full range in that dimension
+
+**Processing Options:**
+- `--downsample`: Downsampling factor (default: `1` = no downsampling)
+- `--precision`: Numerical precision `float32` or `float64` (default: `float64`)
+- `--mean-mol-wt`: Mean molecular weight (default: `1.29`)
+
+**Line Selection:**
+- `--limit-lines`: Limit to specific lines, e.g., `--limit-lines Fe12_195.1190 Fe12_195.1790`
+
+#### Output
+
+The synthesis produces a pickle file containing:
+- `line_cubes`: Individual NDCube objects for each spectral line with proper WCS
+- `config`: Runtime configuration for reproducibility
+- Additional technical data for internal use
+
+#### Performance Tips
+
+- Use `--downsample 2` or `--downsample 4` for initial testing
+- Use `--precision float32` to reduce memory usage (may affect accuracy)
+- Use `--limit-lines` to synthesize only specific lines for development
+- Use spatial cropping to focus on regions of interest and reduce computation time
+- Monitor memory usage - full resolution synthesis can require 50+ GB RAM
+- Side views (`--integration-axis x` or `y`) may require different velocity files
+
+#### Working with Synthesis Results
+
+The synthesis results can be loaded and analyzed using the package API:
+
+```python
+import euvst_response
+
+# Load synthesis results - this sums all line cubes into a single cube
+# By default uses Fe XII 195.119 Å as reference for wavelength grid
+cube = euvst_response.load_atmosphere("./run/input/synthesised_spectra.pkl")
+print(f"Combined cube shape: {cube.data.shape}")
+
+# Access individual line cubes if needed
+import pickle
+with open("./run/input/synthesised_spectra.pkl", "rb") as f:
+    data = pickle.load(f)
+
+# Access individual line cubes
+fe12_195 = data["line_cubes"]["Fe12_195.1190"]
+print(f"Fe XII 195.119 cube shape: {fe12_195.data.shape}")
+print(f"Rest wavelength: {fe12_195.meta['rest_wav']}")
+
+# List all available lines
+print(f"Available spectral lines: {list(data['line_cubes'].keys())}")
+```
+
+#### Pre-computed Atmospheres
+
+This step can require a lot of memory at full resolution. A fully synthesised atmosphere using the Cheung et al. (2018) atmosphere (doi:10.1038/s41550-018-0629-3) for the Fe XII 195.119 and 195.179 lines, including 5 background lines from each side, can be downloaded here: https://liveuclac-my.sharepoint.com/:f:/g/personal/ucasjem_ucl_ac_uk/Es-ts6rwXIlInAweGI7hmdMB5BoGqv9uSpIXOvMkzhS3cw?e=54si7R
+
+**Important:** You can place the synthesised atmosphere file anywhere and specify its location using the `synthesis_file` parameter in your YAML configuration file. The default location is `./run/input/synthesised_spectra.pkl`.
+
+### 3. Simulate the instrument response
+
+#### Configuration File
+
+ECLIPSE uses YAML configuration files to specify simulation parameters. You can specify single values or lists of values for parameter sweeps.
+
+**Key configuration options:**
+- `instrument`: Choose between SWC (EUVST-SW) or EIS (Hinode)
+- `synthesis_file`: Path to the synthesised spectra pickle file (default: `./run/input/synthesised_spectra.pkl`)
+- `reference_line`: Spectral line to use as reference for wavelength grid when combining all lines (default: `Fe12_195.1190`)
+- `expos`: Exposure time(s) for simulations
+- `n_iter`: Number of Monte Carlo iterations
+- Parameter sweeps for filters, detector settings, etc.
+
+Here's a complete example configuration file:
+
+```yaml
+# Instrument selection
+instrument: SWC  # Options: SWC (EUVST Short Wavelength) or EIS (Hinode/EIS)
+
+# Synthesis file path - location of the synthesised spectra pickle file
+synthesis_file: ./run/input/synthesised_spectra.pkl  # Default location
+
+# Reference line for wavelength grid and metadata when combining all spectral lines
+reference_line: Fe12_195.1190  # Default reference line (Fe XII 195.119 Å)
+
+# Point Spread Function
+psf: False  # Enable PSF convolution
+# Or test with and without PSF:
+# psf: [True, False]  # Run simulations both with and without PSF
+
+# Exposure times - can be single value or list
+expos: [0.5 s, 1 s, 2 s, 5 s, 10 s, 20 s, 40 s, 80 s]
+
+# Monte Carlo simulation parameters
+n_iter: 1000      # Number of Monte Carlo iterations
+ncpu: -1        # Number of CPU cores (-1 = use all available)
+
+# Parameter sweeps - you can specify single values or lists for any parameter
+# The simulation will run all combinations of parameters
+
+# Slit width
+slit_width: 0.2 arcsec  # Narrowest slit on EUVST
+
+# Filter parameters (SWC only)
+# Thickness of aluminum oxide layer on entrance filter
+oxide_thickness: 95 angstrom  # Default (expected value)
+
+# Carbon contamination thickness on filter
+c_thickness: 0 angstrom  # Default (ideal case, no contamination)
+
+# Aluminum filter thickness
+aluminium_thickness: 1485 angstrom  # Default (expected value)
+
+# CCD temperature for dark current calculation
+ccd_temperature: -60 Celsius  # Default (expected operating temperature)
+
+# Visible stray light level
+vis_sl: 0 photon / (s * pixel)  # Default, (ideal case, no stray light)
+```
+
+For guidence on recommended values, see McKevitt et al. (2025) (in prep.).
+
+#### Running Simulations
+
+Run the instrument response function using:
+```bash
+eclipse --config ./run/input/config.yaml
+```
+
+**Command-line options:**
+- `--config`: Path to YAML configuration file (required)
+- `--debug`: Enable debug mode with IPython breakpoints on errors (optional)
+
+#### Output
+
+Results are saved as pickle files in the `run/result/` directory with the same base name as the configuration file. The output includes:
+- Simulated detector signals (DN and photon counts)
+- Fitted spectral line parameters (intensity, velocity, width)
+- Statistical analysis of velocity precision vs. exposure time
+- Ground truth comparisons
+
+## 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.5.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+euvst_response/__init__.py,sha256=DKFpqD73FrVmdRx5s29ufqJpl5rxqLGRZ2CEvXzUueY,2105
+euvst_response/analysis.py,sha256=N-yWpd7G2QuBpDTTg2AmYBZk06iqj0zTwb1aoVJF01U,29601
+euvst_response/cli.py,sha256=AIgXpTL6uTjUx4whTYbbo7hr4s0FQCM4TnJbEClIelA,3004
+euvst_response/config.py,sha256=PXFFCH2Bigr13qDEpNZT4YsWdY4JlmWlpnsEjxWEvrQ,15192
+euvst_response/data_processing.py,sha256=6w08qf7NE9lH9MpWbRJtSlWL-6_0GRXGN4RwGicLljQ,9718
+euvst_response/fitting.py,sha256=NSYnT1x9mzbp1R7CEmu71gPUiT2_jJhPSK7svRR2UXE,4920
+euvst_response/main.py,sha256=aSyg2AqgcoLGpX9bCJYWNYz7pKdMZL9J-kd4DaDVTy4,21251
+euvst_response/monte_carlo.py,sha256=-slxTDrBiLh3waZ984fGcYbSIunUmax9honvseNtqg4,5837
+euvst_response/pinhole_diffraction.py,sha256=HgwQMnbZwZQjCoE0INZpWRSVn8WOfrUnCCTGI302Xx0,10018
+euvst_response/psf.py,sha256=Csz1635VwU4bHYgj18qrdoOOqlHJNlzTOzDlLed9P2o,1651
+euvst_response/radiometric.py,sha256=zZqgXT9Vn8Jp2B7e5-PejkcGfZ_1tDDVh-hq4oEGAwU,17501
+euvst_response/synthesis.py,sha256=ALgJ7SfFyzrYl-aL73_AcTEHd1vSyzfj0kDR4STAL1g,33705
+euvst_response/synthesis_cli.py,sha256=XGiMXg0A7pFWXn9Yfps2jDfBphG26vnmLaxJBxalebU,258
+euvst_response/utils.py,sha256=zAiKn2eGJet5glMiXhqWMJ4-sX_JuZHDCTUgMnrYQPI,5360
+euvst_response/data/throughput/grating_reflection_efficiency.dat,sha256=OsaBQ5XhnuZU1EUoDHUZqH9UFThhwNF6s-SnnCh28zI,648
+euvst_response/data/throughput/primary_mirror_coating_reflectance.dat,sha256=1ibNeUajw1zzLfDc25juSAcjwSf4r7Fz1RHZjledcEE,653
+euvst_response/data/throughput/source.txt,sha256=pb3LQz4UzFbE0-ObUOtYpHXgSrOT4CS4Y-2iJwgLn4A,130
+euvst_response/data/throughput/throughput_aluminium_1000_angstrom.dat,sha256=19SmUQBMZsi-yUnmbattTtmPQJZSK8F4yWGvGciZnl8,14100
+euvst_response/data/throughput/throughput_aluminium_oxide_1000_angstrom.dat,sha256=-opQvD-6oK--g6dy5Rcfm1G_2kB0CdHhFk7Bqe7EFzw,14101
+euvst_response/data/throughput/throughput_carbon_1000_angstrom.dat,sha256=TuVMkAr9JBMavD0UVth7kNTvDXLSr47Z60UouQdMUbU,14096
+solarc_eclipse-0.5.0.dist-info/licenses/LICENSE,sha256=j4MYreXd863pwE5tkHNS1jEuA_cpsiv4bEFKODaA7Qw,64
+solarc_eclipse-0.5.0.dist-info/METADATA,sha256=YLF2NrVbkf7Y4_7GZEl8dN1Dj7Ap5mtgf4N5AiQa4XY,12893
+solarc_eclipse-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+solarc_eclipse-0.5.0.dist-info/entry_points.txt,sha256=IeUgF0srH4zC4eaDoz9g8U7aRa4T9N9S1YcKnYLITQc,203
+solarc_eclipse-0.5.0.dist-info/top_level.txt,sha256=xnMo4ka9WH0Cw_EIkb66PpCsWuoZJ2aAFh9IL2p2_3s,15
+solarc_eclipse-0.5.0.dist-info/RECORD,,

solarc_eclipse-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

solarc_eclipse-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+eclipse = euvst_response.cli:main
+solarc-eclipse = euvst_response.cli:main
+synthesise-spectra = euvst_response.synthesis_cli:main
+synthesise_spectra = euvst_response.synthesis_cli:main

solarc_eclipse-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+Do not use or edit this code without permission from the author.

solarc_eclipse-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+euvst_response