jeb/spie2026

.github/workflows/bump_on_dependency.yml

@@ -1,21 +1,20 @@
-name: Bump dev version on dependency PR
-on:
- pull_request:
- types: [closed]
-
-jobs:
- Bump:
- name: Bump prerelease version
- if: >
- github.event.pull_request.merged == true &&
- github.event.pull_request.base.ref == 'main' &&
- contains(
- github.event.pull_request.labels.*.name,
- 'dependencies'
- )
- uses: AstarVienna/DevOps/.github/workflows/bump.yml@main
- secrets: inherit
- with:
- rule: prerelease
- branch: main
-
+name: Bump dev version on dependency PR
+on:
+ pull_request:
+ types: [closed]
+
+jobs:
+ Bump:
+ name: Bump prerelease version
+ if: >
+ github.event.pull_request.merged == true &&
+ github.event.pull_request.base.ref == 'main' &&
+ contains(
+ github.event.pull_request.labels.*.name,
+ 'dependencies'
+ )
+ uses: AstarVienna/DevOps/.github/workflows/bump.yml@main
+ secrets: inherit
+ with:
+ rule: prerelease
+ branch: main

scopesim/defaults.yaml

@@ -13,6 +13,7 @@ properties :
 
  spectral_bin_width : !!float 1E-4
  spectral_resolution: 5000
+ trace_flux_jacobian : False
  minimum_throughput : !!float 1E-6
  minimum_pixel_flux : 1
 

scopesim/effects/__init__.py

@@ -12,6 +12,7 @@
 from .surface_list import *
 from .ter_curves import *
 from . import ter_curves_utils
+from .illumination import *
 
 from .detector_list import *
 from .electronic import *

scopesim/effects/atmo_dispersion.py

@@ -218,7 +218,7 @@ class ADShift(ShiftFoV3D):
  def __init__(self, **kwargs):
  super().__init__(**kwargs)
 
- self.target, self.location, self.time = get_observation_info_from_cmds(self.cmds)
+ self.target, self.location, self.time, _ = get_observation_info_from_cmds(self.cmds)
 
  self.zenith_angle = get_zenith_angle(self.target, self.location, self.time) * u.deg
 
@@ -298,9 +298,12 @@ def __init__(self, **kwargs):
  if 'filename' not in kwargs and 'zenith_angle_error' not in kwargs:
  raise ValueError("Residuals must be supplied through either filename or zenith_angle_error.")
 
- self.target, self.location, self.time = get_observation_info_from_cmds(self.cmds)
+ self.target, self.location, self.time, _ = get_observation_info_from_cmds(self.cmds)
 
  self.zenith_angle = get_zenith_angle(self.target, self.location, self.time) * u.deg
+ self._ad_shift_cache_key = None
+ self._ad_shift_cache = None
+ self._residual_interpolator_cache = None
 
  def get_shifts(self, obj: FieldOfView3D):
  """
@@ -313,35 +316,24 @@ def get_shifts(self, obj: FieldOfView3D):
 
  if self.data is not None and isinstance(self.data, Table):
  logger.info(f'Residuals supplied by {self.meta["filename"]}')
- Z = self.data.colnames
- Z.remove("wavelength")
- lam_um = quantity_from_table("wavelength", self.data, "um").value
- R = np.array([np.array(self.data[z]).astype(float) for z in Z])
- R_unit = u.Unit(self.data.meta.get("shifts_unit", "arcsec"))
- Z = np.array(Z).astype(float)
- adc_opt_resid = RegularGridInterpolator((Z, lam_um), R, method="linear", bounds_error=False,
- fill_value=None)
-
- adc_nir_resid = lambda xy: adc_opt_resid((xy[0], (xy[1] - 1) / 1.5 * (1.1 - .31) + .31)) # scale to nIR
- # 300-500 & 500-1000
- adc_ub_resid = lambda xy: adc_opt_resid((xy[0], (xy[1] - .3) / .2 * (1.1 - .31) + .31)) / 2 # scale
- adc_gri_resid = lambda xy: adc_opt_resid((xy[0], (xy[1] - .5) / .5 * (1.1 - .31) + .31)) / 2 # scale to nIR
+ R_unit, adc_opt_resid = self._get_residual_interpolator()
 
  if self.meta.get("use_broadband", False):
  use = wave < 1.0 * u.um
  shifts[use] += (adc_opt_resid(
  (self.zenith_angle.to_value(u.deg), wave[use].to_value(u.um))) * R_unit).to(u.arcsec)
  else:
  use = wave < 0.5 * u.um
- res1 = (adc_ub_resid(
+ res1 = (self._adc_ub_resid(adc_opt_resid,
  (self.zenith_angle.to_value(u.deg), wave[use].to_value(u.um))) * R_unit).to(u.arcsec)
  shifts[use] += res1
  use = ~use & (wave < 1.0 * u.um)
- res2 = (adc_gri_resid(
+ res2 = (self._adc_gri_resid(adc_opt_resid,
  (self.zenith_angle.to_value(u.deg), wave[use].to_value(u.um))) * R_unit).to(u.arcsec)
  shifts[use] += res2
  use = wave >= 1.0 * u.um
- res3 = (adc_nir_resid((self.zenith_angle.to_value(u.deg), wave[use].to_value(u.um))) * R_unit).to(u.arcsec)
+ res3 = (self._adc_nir_resid(adc_opt_resid,
+ (self.zenith_angle.to_value(u.deg), wave[use].to_value(u.um))) * R_unit).to(u.arcsec)
  shifts[use] += res3
 
  if self.meta.get('zenith_angle_error', 0.0) != 0.0:
@@ -354,11 +346,13 @@ def get_shifts(self, obj: FieldOfView3D):
  ad_kwargs[k] = v
  else:
  ad_kwargs[k] = self.meta[k]
- ad = ADShift(**ad_kwargs, cmds=self.cmds)
+ ad = self._get_ad_shift(ad_kwargs)
+ ad.zenith_angle = self.zenith_angle
  ad_shift = ad._get_shifts_arcsec(obj) # get shift at zenith angle
  ad.zenith_angle = ad.zenith_angle + self.meta.get('zenith_angle_error', 0.0) * u.deg # update zenith angle
  ad_shift -= ad._get_shifts_arcsec(obj) # subtract shift at (zenith angle + error) to get residual
  shifts += ad_shift
+ ad.zenith_angle = self.zenith_angle
 
  pos_angle_y = field_rotation_pa_y(obj.hdu.header)
  par_angle = get_parallactic_angle(self.target, self.location, self.time)
@@ -368,6 +362,43 @@ def get_shifts(self, obj: FieldOfView3D):
  dx = -1 * shifts * np.sin(theta)
  return dx, dy
 
+ def _get_residual_interpolator(self):
+ if self._residual_interpolator_cache is None:
+ Z = list(self.data.colnames)
+ Z.remove("wavelength")
+ lam_um = quantity_from_table("wavelength", self.data, "um").value
+ R = np.array([np.array(self.data[z]).astype(float) for z in Z])
+ R_unit = u.Unit(self.data.meta.get("shifts_unit", "arcsec"))
+ Z = np.array(Z).astype(float)
+ adc_opt_resid = RegularGridInterpolator(
+ (Z, lam_um), R, method="linear", bounds_error=False,
+ fill_value=None,
+ )
+ self._residual_interpolator_cache = (R_unit, adc_opt_resid)
+ return self._residual_interpolator_cache
+
+ @staticmethod
+ def _adc_nir_resid(adc_opt_resid, xy):
+ return adc_opt_resid((xy[0], (xy[1] - 1) / 1.5 * (1.1 - .31) + .31))
+
+ @staticmethod
+ def _adc_ub_resid(adc_opt_resid, xy):
+ return adc_opt_resid((xy[0], (xy[1] - .3) / .2 * (1.1 - .31) + .31)) / 2
+
+ @staticmethod
+ def _adc_gri_resid(adc_opt_resid, xy):
+ return adc_opt_resid((xy[0], (xy[1] - .5) / .5 * (1.1 - .31) + .31)) / 2
+
+ def _get_ad_shift(self, ad_kwargs):
+ cache_key = tuple(
+ (key, str(from_currsys(value, self.cmds)))
+ for key, value in sorted(ad_kwargs.items())
+ )
+ if self._ad_shift_cache is None or cache_key != self._ad_shift_cache_key:
+ self._ad_shift_cache = ADShift(**ad_kwargs, cmds=self.cmds)
+ self._ad_shift_cache_key = cache_key
+ return self._ad_shift_cache
+
 
 ########################### AD utils ###############################
 def field_rotation_pa_y(header) -> float:
@@ -492,4 +523,4 @@ def refractive_index(wavelength: u.Quantity, temp: u.Quantity, pressure: u.Quant
 
  nprop = 1 + (ρa / ρaxs) * (naxs - 1) + (ρw / ρws) * (nws - 1)
 
- return nprop
+ return nprop

scopesim/effects/detector_list.py

@@ -139,6 +139,7 @@ def __init__(self, **kwargs):
  super().__init__(**kwargs)
  params = {
  "pixel_scale": "!INST.pixel_scale", # arcsec
+ "plate_scale": "!INST.plate_scale", # arcsec / mm
  "active_detectors": "all",
  }
  self.meta.update(params)

scopesim/effects/electronic/__init__.py

@@ -24,7 +24,7 @@
 
 from .electrons import LinearityCurve, ADConversion, InterPixelCapacitance
 from .noise import (Bias, PoorMansHxRGReadoutNoise, BasicReadoutNoise,
-ShotNoise, DarkCurrent, PixelResponseNonUniformity)
+PixelResponseNonUniformity, ShotNoise, DarkCurrent)
 from .exposure import AutoExposure, ExposureIntegration, ExposureOutput
 from .pixels import ReferencePixelBorder, BinnedImage, UnequalBinnedImage
 from .dmps import DetectorModePropertiesSetter

scopesim/effects/electronic/noise.py

@@ -215,7 +215,7 @@ def apply_to(self, obj, **kwargs):
  return obj
 
  def plot(self, det_id=None):
- """Plot effect."""
+ """Plot the cached gain map."""
  if not self._gain_maps:
  raise RuntimeError("No gain map yet - run a simulation first.")
  key = det_id if det_id in self._gain_maps else next(iter(self._gain_maps))