pyreduce-astro 0.7a4__cp314-cp314-win_amd64.whl

pyreduce/clib/slit_func_2d_xi_zeta_bd.h

@@ -0,0 +1,55 @@
+typedef struct
+{
+    int x;
+    int y;    /* Coordinates of target pixel x,y  */
+    double w; /* Contribution weight <= 1/osample */
+} xi_ref;
+
+typedef struct
+{
+    int x;
+    int iy;   /* Contributing subpixel  x,iy      */
+    double w; /* Contribution weight <= 1/osample */
+} zeta_ref;
+
+int slit_func_curved(int ncols,
+                     int nrows,
+                     int ny,
+                     double *im,
+                     double *pix_unc,
+                     unsigned char *mask,
+                     double *ycen,
+                     int *ycen_offset,
+                     int y_lower_lim,
+                     int osample,
+                     double lambda_sP,
+                     double lambda_sL,
+                     int maxiter,
+                     double *PSF_curve,
+                     double *sP,
+                     double *sL,
+                     double *model,
+                     double *unc,
+                     double *info);
+
+int xi_zeta_tensors(
+                    int ncols,
+                    int nrows,
+                    int ny,
+                    double *ycen,
+                    int *ycen_offset,
+                    int y_lower_lim,
+                    int osample,
+                    double *PSF_curve,
+                    xi_ref *xi,
+                    zeta_ref *zeta,
+                    int *m_zeta);
+
+int create_spectral_model(
+    int ncols,
+    int nrows,
+    int osample,
+    xi_ref* xi,
+    double* spec,
+    double* slitfunc,
+    double* img);

pyreduce/clib/slit_func_bd.c

@@ -0,0 +1,362 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+#define omega_index(x, y, z) z + (y * ny) + (x * ny * nrows)
+/*----------------------------------------------------------------------------*/
+/**
+  @brief    Solve a sparse system of linear equations
+  @param    a   2D array [n,nd]i
+  @param    r   array of RHS of size n
+  @param    n   number of equations
+  @param    nd  width of the band (3 for tri-diagonal system)
+  @return   0 on success, -1 on incorrect size of "a" and -4 on
+            degenerate matrix
+
+  Solve a sparse system of linear equations with band-diagonal matrix.
+  Band is assumed to be symmetrix relative to the main diaginal.
+
+  nd must be an odd number. The main diagonal should be in a(*,nd/2)
+  The first lower subdiagonal should be in a(1:n-1,nd/2-1), the first
+  upper subdiagonal is in a(0:n-2,nd/2+1) etc. For example:
+                    / 0 0 X X X \
+                    | 0 X X X X |
+                    | X X X X X |
+                    | X X X X X |
+              A =   | X X X X X |
+                    | X X X X X |
+                    | X X X X X |
+                    | X X X X 0 |
+                    \ X X X 0 0 /
+ */
+/*----------------------------------------------------------------------------*/
+static int bandsol(
+    double *a,
+    double *r,
+    int n,
+    int nd)
+{
+  double aa;
+  int i, j, k;
+
+  //if(fmod(nd,2)==0) return -1;
+
+  /* Forward sweep */
+  for (i = 0; i < n - 1; i++)
+  {
+    aa = a[i + n * (nd / 2)];
+    //if(aa==0.e0) return -3;
+    r[i] /= aa;
+    for (j = 0; j < nd; j++)
+      a[i + j * n] /= aa;
+    for (j = 1; j < min(nd / 2 + 1, n - i); j++)
+    {
+      aa = a[i + j + n * (nd / 2 - j)];
+      //if(aa==0.e0) return -j;
+      r[i + j] -= r[i] * aa;
+      for (k = 0; k < n * (nd - j); k += n)
+        a[i + j + k] -= a[i + k + n * j] * aa;
+    }
+  }
+
+  /* Backward sweep */
+  r[n - 1] /= a[n - 1 + n * (nd / 2)];
+  for (i = n - 1; i > 0; i--)
+  {
+    for (j = 1; j <= min(nd / 2, i); j++)
+      r[i - j] -= r[i] * a[i - j + n * (nd / 2 + j)];
+    //if(a[i-1+n*(nd/2)]==0.e0) return -5;
+    r[i - 1] /= a[i - 1 + n * (nd / 2)];
+  }
+
+  //if(a[n*(nd/2)]==0.e0) return -6;
+  r[0] /= a[n * (nd / 2)];
+  return 0;
+}
+
+int slit_func_vert(int ncols,        /* Swath width in pixels                                 */
+                   int nrows,        /* Extraction slit height in pixels                      */
+                   double *im,       /* Image to be decomposed                                */
+                   double *pix_unc,  /* Image Uncertianty to be decomposed                                */
+                   int *mask,        /* Initial and final mask for the swath                  */
+                   double *ycen,     /* Order centre line offset from pixel row boundary      */
+                   int osample,      /* Subpixel ovsersampling factor                         */
+                   double lambda_sP, /* Smoothing parameter for the spectrum, coiuld be zero  */
+                   double lambda_sL, /* Smoothing parameter for the slit function, usually >0 */
+                   double *sP,       /* Spectrum resulting from decomposition                 */
+                   double *sL,       /* Slit function resulting from decomposition            */
+                   double *model,    /* Model constructed from sp and sf                      */
+                   double *unc       /* Spectrum uncertainties                                */
+)
+{
+  int x, y, iy, jy, iy1, iy2, ny, nd;
+  double step, d1, d2, sum, norm, dev, lambda, diag_tot, sP_change, sP_max;
+  int info, iter, isum;
+  /* Initialise */
+  nd = 2 * osample + 1;
+  ny = osample * (nrows + 1) + 1; /* The size of the sf array */
+  step = 1.e0 / osample;
+  double *E = malloc(ncols * sizeof(double));                    // double E[ncols];
+  double *sP_old = malloc(ncols * sizeof(double));               // double sP_old[ncols];
+  double *Aij = malloc(ny * (2 * osample + 1) * sizeof(double)); // double Aij[ny*ny];
+  double *bj = malloc(ny * sizeof(double));                      // double bj[ny];
+  double *Adiag = malloc(ncols * 3 * sizeof(double));            // double Adiag[ncols*3];
+  double *omega = malloc(ny * nrows * ncols * sizeof(double));   // double omega[ny][nrows][ncols];
+  double *p_bj = malloc(ncols * sizeof(double));                 // index as: [iy+(y*ny)+(x*ny*nrows)]
+
+  for (int k = 0; k < ncols * 3; k++)
+    Adiag[k] = 0; // Initialize to zero
+
+  /*
+  Construct the omega tensor. Normally it has the dimensionality of
+  ny*nrows*ncols.
+  The tensor is mostly empty and can be easily compressed to ny*nx, but
+  this will complicate matrix operations at later stages. I will keep
+  it as it is for now.
+  Note, that omega is used in in the equations for sL, sP and for the model
+  but it does not involve the data, only the geometry. Thus it can be
+  pre-computed once.
+  */
+  for (x = 0; x < ncols; x++)
+  {
+    iy2 = osample - floor(ycen[x] / step) - 1;
+    iy1 = iy2 - osample;
+
+    d1 = fmod(ycen[x], step);
+    if (d1 == 0)
+      d1 = step;
+    d2 = step - d1;
+
+    for (y = 0; y < nrows; y++)
+    {
+      iy1 += osample;
+      iy2 += osample;
+      for (iy = 0; iy < ny; iy++)
+      {
+        if (iy < iy1)
+          omega[omega_index(x, y, iy)] = 0.;
+        else if (iy == iy1)
+          omega[omega_index(x, y, iy)] = d1;
+        else if (iy > iy1 && iy < iy2)
+          omega[omega_index(x, y, iy)] = step;
+        else if (iy == iy2)
+          omega[omega_index(x, y, iy)] = d2;
+        else
+          omega[omega_index(x, y, iy)] = 0.;
+      }
+    }
+  }
+
+  /* Loop through sL , sP reconstruction until convergence is reached */
+  iter = 0;
+  do
+  {
+    /* Compute slit function sL */
+    /* Fill in SLE arrays */
+    diag_tot = 0.e0;
+    for (iy = 0; iy < ny; iy++)
+    {
+      bj[iy] = 0.e0;
+      for (jy = max(iy - osample, 0); jy <= min(iy + osample, ny - 1); jy++)
+      {
+        Aij[iy + ny * (jy - iy + osample)] = 0.e0;
+        for (x = 0; x < ncols; x++)
+        {
+          sum = 0.e0;
+          for (y = 0; y < nrows; y++)
+            sum += omega[omega_index(x, y, iy)] *
+                   omega[omega_index(x, y, jy)] * mask[y * ncols + x];
+          Aij[iy + ny * (jy - iy + osample)] += sum * sP[x] * sP[x];
+        }
+      }
+      for (x = 0; x < ncols; x++)
+      {
+        sum = 0.e0;
+        for (y = 0; y < nrows; y++)
+          sum += omega[omega_index(x, y, iy)] *
+                 mask[y * ncols + x] * im[y * ncols + x];
+        bj[iy] += sum * sP[x];
+      }
+      diag_tot += Aij[iy + ny * osample];
+    }
+
+    /* Scale regularization parameters */
+    lambda = lambda_sL * diag_tot / ny;
+
+    /* Add regularization parts for the slit function */
+    Aij[ny * osample] += lambda;       /* Main diagonal  */
+    Aij[ny * (osample + 1)] -= lambda; /* Upper diagonal */
+    for (iy = 1; iy < ny - 1; iy++)
+    {
+      Aij[iy + ny * (osample - 1)] -= lambda;  /* Lower diagonal */
+      Aij[iy + ny * osample] += lambda * 2.e0; /* Main diagonal  */
+      Aij[iy + ny * (osample + 1)] -= lambda;  /* Upper diagonal */
+    }
+    Aij[ny - 1 + ny * (osample - 1)] -= lambda; /* Lower diagonal */
+    Aij[ny - 1 + ny * osample] += lambda;       /* Main diagonal  */
+
+    /* Solve the system of equations */
+    info = bandsol(Aij, bj, ny, nd);
+    if (info)
+      printf("Bandsol exited with %d", info);
+
+    /* Normalize the slit function */
+    norm = 0.e0;
+    for (iy = 0; iy < ny; iy++)
+    {
+      sL[iy] = bj[iy];
+      norm += sL[iy];
+    }
+    norm /= osample;
+    for (iy = 0; iy < ny; iy++)
+      sL[iy] /= norm;
+
+    /* Compute spectrum sP */
+    for (x = 0; x < ncols; x++)
+    {
+      Adiag[x + ncols] = 0.e0;
+      E[x] = 0.e0;
+      for (y = 0; y < nrows; y++)
+      {
+        sum = 0.e0;
+        for (iy = 0; iy < ny; iy++)
+        {
+          sum += omega[omega_index(x, y, iy)] * sL[iy];
+        }
+
+        Adiag[x + ncols] += sum * sum * mask[y * ncols + x];
+        E[x] += sum * im[y * ncols + x] * mask[y * ncols + x];
+      }
+    }
+    if (lambda_sP > 0.e0)
+    {
+      norm = 0.e0;
+      for (x = 0; x < ncols; x++)
+      {
+        sP_old[x] = sP[x];
+        norm += sP[x];
+      }
+      norm /= ncols;
+      lambda = lambda_sP * norm;
+      Adiag[0] = 0.e0;
+      Adiag[0 + ncols] += lambda;
+      Adiag[0 + ncols * 2] -= lambda;
+      for (x = 1; x < ncols - 1; x++)
+      {
+        Adiag[x] = -lambda;
+        Adiag[x + ncols] += 2.e0 * lambda;
+        Adiag[x + ncols * 2] = -lambda;
+      }
+      Adiag[ncols - 1] -= lambda;
+      Adiag[ncols - 1 + ncols] += lambda;
+      Adiag[ncols - 1 + 2 * ncols] = 0.e0;
+
+      info = bandsol(Adiag, E, ncols, 3);
+      for (x = 0; x < ncols; x++)
+        sP[x] = E[x];
+    }
+    else
+    {
+      for (x = 0; x < ncols; x++)
+      {
+        sP_old[x] = sP[x];
+        sP[x] = E[x] / Adiag[x + ncols];
+      }
+    }
+
+    /* Compute the model */
+    for (y = 0; y < nrows; y++)
+    {
+      for (x = 0; x < ncols; x++)
+      {
+        sum = 0.e0;
+        for (iy = 0; iy < ny; iy++)
+          sum += omega[omega_index(x, y, iy)] * sL[iy];
+        model[y * ncols + x] = sum * sP[x];
+      }
+    }
+
+    /* Compare model and data */
+    sum = 0.e0;
+    isum = 0;
+    for (y = 0; y < nrows; y++)
+    {
+      for (x = 0; x < ncols; x++)
+      {
+        sum += mask[y * ncols + x] * (model[y * ncols + x] - im[y * ncols + x]) *
+               (model[y * ncols + x] - im[y * ncols + x]);
+        isum += mask[y * ncols + x];
+      }
+    }
+    dev = sqrt(sum / isum);
+
+    /* Adjust the mask marking outlyers */
+    for (y = 0; y < nrows; y++)
+    {
+      for (x = 0; x < ncols; x++)
+      {
+        if (fabs(model[y * ncols + x] - im[y * ncols + x]) > 6. * dev)
+          mask[y * ncols + x] = 0;
+        else
+          mask[y * ncols + x] = 1;
+      }
+    }
+
+    /* Compute the change in the spectrum */
+    sP_change = 0.e0;
+    sP_max = 1.e0;
+    for (x = 0; x < ncols; x++)
+    {
+      if (sP[x] > sP_max)
+        sP_max = sP[x];
+      if (fabs(sP[x] - sP_old[x]) > sP_change)
+        sP_change = fabs(sP[x] - sP_old[x]);
+    }
+    /* Check the convergence */
+  } while (iter++ < 5 && sP_change > 1e-5 * sP_max);
+
+  /* Uncertainty estimate */
+  for (x = 0; x < ncols; x++)
+  {
+    unc[x] = 0.;
+    p_bj[x] = 0.;
+  }
+  for (x = 0; x < ncols; x++)
+  {
+    // Loop through all pixels contributing to x
+    for (y = 0; y < nrows; y++)
+    {
+      unc[x] += (im[y * ncols + x] - model[y * ncols + x]) *
+                (im[y * ncols + x] - model[y * ncols + x]) *
+                sL[y] * mask[y * ncols + x];
+      unc[x] += pix_unc[y * ncols + x] * pix_unc[y * ncols + x] *
+                sL[y] * mask[y * ncols + x];
+      // Norm
+      p_bj[x] += sL[y] * mask[y * ncols + x];
+    }
+  }
+  for (x = 0; x < ncols; x++)
+  {
+    unc[x] = sqrt(unc[x] / p_bj[x] * nrows);
+  }
+
+  if (!(sP[0] == sP[0]))
+  {
+    printf("SOMETHING WENT WRONG STOP HERE!!!\n");
+    // raise(SIGINT);
+  }
+
+  free(E);
+  free(sP_old);
+  free(omega);
+  free(Aij);
+  free(bj);
+  free(Adiag);
+  free(p_bj);
+
+  return 0;
+}

pyreduce/clib/slit_func_bd.h

@@ -0,0 +1,17 @@
+
+//int  locate_clusters(int argc, void *argv[]);
+
+int slit_func_vert(int ncols,        /* Swath width in pixels                                 */
+                   int nrows,        /* Extraction slit height in pixels                      */
+                   double *im,       /* Image to be decomposed                                */
+                   double *pix_unc,  /* Image Uncertianty to be decomposed                                */
+                   int *mask,        /* Initial and final mask for the swath                  */
+                   double *ycen,     /* Order centre line offset from pixel row boundary      */
+                   int osample,      /* Subpixel ovsersampling factor                         */
+                   double lambda_sP, /* Smoothing parameter for the spectrum, coiuld be zero  */
+                   double lambda_sL, /* Smoothing parameter for the slit function, usually >0 */
+                   double *sP,       /* Spectrum resulting from decomposition                 */
+                   double *sL,       /* Slit function resulting from decomposition            */
+                   double *model,    /* Model constructed from sp and sf                      */
+                   double *unc       /* Spectrum uncertainties                                */
+);

pyreduce/clipnflip.py

@@ -0,0 +1,147 @@
+"""
+Module that
+    - Clips remove pre- and overscan regions
+    - Flips orients the image so that orders are roughly horizontal
+"""
+
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+def clipnflip(
+    image, header, xrange=None, yrange=None, orientation=None, transpose=None
+):
+    """
+    Process an image and associated FITS header already in memory as follows:
+    1. Trim image to desired subregion: newimage = image(xlo:xhi,ylo:yhi)
+    2. Transform to standard orientation (red at top, orders run left to right)
+
+    Parameters
+    -----------
+    image : array[nrow, ncol]
+        raw image to be processed.
+    header : fits.header, dict
+        FITS header of the image
+    xrange : tuple(int, int), optional
+        column - range to keep in the image (default: data from header/instrument)
+    yrange : tuple(int, int), optional
+        row - range to keep in the image (default: data from header/instrument)
+    orientation : int, optional
+        number of counterclockwise 90 degrees rotation to apply to the image (default: data from header/instrument)
+    transpose : bool, optional
+        if True the image will be transposed before rotation (default: data from header/instrument)
+
+    Returns
+    -------
+    image : array[yrange, xrange]
+        clipped and flipped image
+
+    Raises
+    -------
+    NotImplementedError
+        nonlinear images are not supported yet
+    """
+
+    # This part depends on how many amplifiers were used for the readout
+    n_amp = header.get("e_ampl", 1)
+    image = np.asarray(image)
+
+    if n_amp > 1:  # pragma: no cover
+        raise NotImplementedError
+        xlo = np.array(header["e_xlo*"].values())
+        xhi = np.array(header["e_xhi*"].values())
+        ylo = np.array(header["e_ylo*"].values())
+        yhi = np.array(header["e_yhi*"].values())
+
+        # Make sure trim region is a subset of actual image.
+        sz = image.shape
+        if (
+            np.any(xlo < 0)
+            | np.any(xlo >= sz[1])
+            | np.any(ylo < 0)
+            | np.any(ylo >= sz[0])
+            | np.any(xhi < 0)
+            | np.any(xhi > sz[1])
+            | np.any(yhi < 0)
+            | np.any(yhi > sz[0])
+        ):
+            raise ValueError("Error specifying trim region")
+
+        linear = header.get("e_linear", False)
+        if not linear:
+            # TODO
+            raise NotImplementedError("only linear for now")
+            # pref = header["e_prefmo"]
+            # image = call_function("nonlinear_" + pref, image, header)
+
+            # i = np.where(header["e_linear"] >= 0)
+            # if len(i) > 0:
+            #     header = header[0 : i - 1 + 1] + header[i + 1 :]
+            # header["e_linear"] = ("t", "image corrected of non-linearity")
+            # ii = np.where(header["e_gain*"] >= 0)
+            # if len(ii) > 0:
+            #     for i in np.arange(0, len(ii) - 1 + 1, 1):
+            #         k = ii[i]
+            #         header = [header[0 : k - 1 + 1], header[k + 1 :]]
+            # header["e_gain"] = (1, "image was converted to e-")
+
+        # Trim image to leave only the subimage containing valid image data.
+        # For two amplifiers we assume a single vertical or horizontal gap.
+        # With four amplifiers we can have a cross.
+
+        if n_amp == 2:
+            # TODO this needs testing
+            if xlo[0] == xlo[1]:
+                xsize = xhi[0] - xlo[0]
+                ysize = yhi[0] - ylo[0] + yhi[1] - ylo[1]
+                timage = np.empty((xsize, ysize), dtype=image.dtype)
+                ysize = yhi[0] - ylo[0]
+                timage[:ysize, :xsize] = image[xlo[0]]
+                timage[ysize:, :xsize] = image[xlo[1]]
+            elif ylo[0] == ylo[1]:
+                xsize = xhi[0] - xlo[0] + xhi[1] - xlo[1]
+                ysize = yhi[0] - ylo[0]
+                timage = np.empty((xsize, ysize), dtype=image.dtype)
+                xsize = xhi[0] - xlo[0]
+                timage[:ysize, :xsize] = image[xlo[0]]
+                timage[:ysize, xsize:] = image[xlo[1]]
+            else:
+                raise Exception(
+                    "The two ccd sections are aligned neither in x nor in y"
+                )
+        elif n_amp == 4:
+            raise NotImplementedError("4-amplifier section is not implemented yet")
+    else:
+        xlo, xhi = xrange if xrange is not None else (header["e_xlo"], header["e_xhi"])
+        ylo, yhi = yrange if yrange is not None else (header["e_ylo"], header["e_yhi"])
+
+        # Make sure trim region is a subset of actual image.
+        sz = image.shape[-2:]
+        if not (0 <= xlo < xhi <= sz[1] and 0 <= ylo < yhi <= sz[0]):
+            raise IndexError(
+                "Image Clipping Indices are not within the image (or in inverse order)"
+            )
+
+        # Trim image to leave only the subimage containing valid image data.
+        timage = image[..., ylo:yhi, xlo:xhi]  # trimmed image
+
+    # Flip image (if necessary) to achieve standard image orientation.
+    orientation = orientation if orientation is not None else header.get("e_orient", 0)
+    # As per the old IDL definition, transpose is true for orientations larger than 4
+    transpose = (
+        transpose
+        if transpose is not None
+        else header.get("e_transpose", (orientation % 8) >= 4)
+    )
+    if transpose:
+        timage = np.transpose(timage, axes=(-1, -2))
+    timage = np.rot90(timage, -1 * orientation, axes=(-2, -1))
+
+    # TODO just sum up groups and stuff?
+    while timage.ndim > 2:
+        timage = np.sum(timage, axis=0)
+
+    return timage