{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "23353fae-2e0d-4ae8-8437-065b7d98b582",
   "metadata": {},
   "source": [
    "#### Grism analysis\n",
    "This script reads a FITS image containing a dispersed grism spectrum and applies wavelength and gain calibration read from a previously generated calibration file. It displays the strip subimage, raw and calibrated spectra, gain vs. wavelength, and a 2x2 plot with the corresponding Jacoby spectrum if available. \n",
    "\n",
    "V. 2.0 (7 March 2023) RLM. \n",
    "\n",
    "*N.B. I will add the ability to generate new calibration files shortly.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "athletic-utility",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numpy.ma as ma\n",
    "import matplotlib.pyplot as plt\n",
    "from astropy.io.fits import getdata\n",
    "from scipy.ndimage import rotate\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.interpolate import interp1d\n",
    "from scipy.ndimage import maximum_filter1d\n",
    "from scipy.signal import medfilt, find_peaks, detrend\n",
    "from datetime import datetime\n",
    "import os,sys\n",
    "\n",
    "balmer = np.array([397.0, 410.17, 434.05, 486.14, 656.45])\n",
    "deg = np.pi/180."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "impossible-doubt",
   "metadata": {},
   "outputs": [],
   "source": [
    "class StopExecution(Exception):\n",
    "    def _render_traceback_(self):\n",
    "        pass\n",
    "\n",
    "class grism_utils:\n",
    "    def __init__(self, grism_image, rot_angle, box, f_wave,f_gain):\n",
    "        ''' Utilities for calibrating and plotting spectra from grism images'''\n",
    "        \n",
    "        self.grism_image = grism_image\n",
    "        self.cal_file = cal_file\n",
    "        self.balmer = np.array([397.0, 410.17, 434.05, 486.14, 656.45])\n",
    "        self.wavelength_range = [380,750]\n",
    "        \n",
    "        ''' Open image, extract header information '''\n",
    "        im, hdr = getdata(grism_image, 0, header=True)\n",
    "        self.im = im\n",
    "        self.hdr = hdr\n",
    "        self.object_name  = hdr['OBJECT']\n",
    "        self.obs_date     = hdr['DATE-OBS'][:-12].replace('T',' ')\n",
    "        self.telescope    = hdr['TELESCOP']\n",
    "        self.camera       = hdr['CAMSN'][0:6]\n",
    "        self.imsize_x = hdr['NAXIS1'] ; self.imsize_y = hdr['NAXIS2']\n",
    "        # Create default plot title\n",
    "        self.title = '%s (%s)\\nGrism spectrum: %s %s' % \\\n",
    "        (self.object_name, self.obs_date, self.telescope, self.camera)\n",
    "                                                     \n",
    "        self.rot_angle = rot_angle\n",
    "        self.box = box\n",
    "        self.f_wave = f_wave\n",
    "        self.f_gain = f_gain\n",
    "        \n",
    "    def summary_info(self):\n",
    "        return self.object_name, self.obs_date,self.telescope,self.camera,self.title,self.im,self.rot_angle, self.box, self.f_wave, self.f_gain\n",
    "    \n",
    "    def create_subimage(self):       \n",
    "        ''' Create a strip subimage using parameters from calibration file, or user-supplied'''\n",
    "        \n",
    "        # Rotate full image                 \n",
    "        im_rot = np.fliplr(self.im)\n",
    "        \n",
    "        # Flip image so L-> R corresponds to short -> long wavelength \n",
    "        im_flip = rotate(im_rot, self.rot_angle,reshape=False)\n",
    "        \n",
    "        # Trim image to subimage using box\n",
    "        xmin,xmax,ymin,ymax = self.box\n",
    "        self.subim = im_flip[ymin:ymax,xmin:xmax]\n",
    "        return self.subim\n",
    "    \n",
    "    def plot_image(self,image = None, vmin=None, vmax=None, title='',figsize =(8,4),cmap='gray'):\n",
    "        '''Plot image: defaults to full image '''\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        zmean = np.median(image); s = np.std(image)\n",
    "        if vmin == None:\n",
    "            vmin = zmean - 2*s; \n",
    "        if vmax == None:\n",
    "            vmax = zmean + 12*s\n",
    "        myplot = ax.imshow(image,cmap=cmap, vmin= vmin, vmax = vmax)\n",
    "        plt.title(title)\n",
    "        return fig \n",
    "    \n",
    "    def calibrate_spectrum(self,subim):\n",
    "        '''Calculates raw spectrum by summing pixels in all vertical slices, then apply wavelength, gain calibration'''\n",
    "\n",
    "        pixels = np.arange(subim.shape[1])\n",
    "        # find sum of pixel values along each column (spectral channel)\n",
    "        uncal_amp = []\n",
    "        for pixel in pixels:\n",
    "            ymax,signal,signal_max = self.__calc_channel_signal(subim,pixel)\n",
    "            uncal_amp.append(signal)\n",
    "        uncal_amp = np.array(uncal_amp)\n",
    "        uncal_amp /= np.max(uncal_amp) # Normalize\n",
    "     \n",
    "        # Wavelength calibration\n",
    "        wave = self.f_wave(pixels)\n",
    "    \n",
    "        # Gain calibration\n",
    "        gain_curve = self.f_gain(wave)\n",
    "        cal_amp = uncal_amp / gain_curve\n",
    "    \n",
    "        spectrum = np.vstack([pixels,wave,uncal_amp,cal_amp])\n",
    "        return spectrum\n",
    "\n",
    "    def __calc_channel_signal(self,subim,xpixel):  \n",
    "        ''' Calculates total counts in specified spectral channel xpixel \n",
    "        by subtracting background and summing. The spectral signal is assumed \n",
    "        to be in middle half of the spectrum. '''\n",
    "        \n",
    "        yvals = subim[:,xpixel]\n",
    "        yindex = np.arange(len(yvals))\n",
    "        \n",
    "        # Choose first, last quartiles for base, fit linear slope\n",
    "        n1 = int(len(yindex)/4); n2 = 3*n1\n",
    "        x1 = yindex[0:n1] ; x2 = yindex[n2:]\n",
    "        y1 = yvals[0:n1]  ; y2 = yvals[n2:]\n",
    "        X = np.concatenate((x1,x2),axis=0)\n",
    "        Y = np.concatenate((y1,y2),axis=0)\n",
    "        c = np.polyfit(X,Y,1) # linear fit  \n",
    "        p = np.poly1d(c)\n",
    "        base = p(yindex)\n",
    "        # Calculate signal vs pixel by subtracting baseline, sum and get index of maximum pixel\n",
    "        signal = yvals - base\n",
    "        signal_max = np.max(signal)\n",
    "        ymax = np.argmax(signal)       \n",
    "        return(ymax, np.sum(signal),signal_max) \n",
    "    \n",
    "    def plot_gain_curve(self, spectrum,wmin=400,wmax=750,color='r',title=''):\n",
    "        ''' Plot the gain vs wavelength using the f_gain function '''\n",
    "        p,w,u,c = self.clip_spectrum(spectrum,wmin,wmax)\n",
    "        gain_curve =self.f_gain(w)\n",
    "        gain_curve /= np.max(gain_curve)\n",
    "        fig, ax = plt.subplots(1, 1,figsize=(8,5))\n",
    "        ax.plot(w,gain_curve,color =color)\n",
    "        plt.suptitle(title)\n",
    "        plt.grid()\n",
    "        return fig\n",
    "    \n",
    "    # Normal 2x2 grism plot\n",
    "    def plot_2x2(self,object_spectrum, reference_spectrum,title='', medavg=1):\n",
    "        ''' Creates 2x2 plot: \n",
    "        UL: uncalibrated object spectrum\n",
    "        UR: Gain curve\n",
    "        LL: Calibrated object spectrum\n",
    "        LR: Reference spectrum \n",
    "        Note: object spectrum has 4 rows (pixels, wavelength, uncal. amp., calib. amplitude), \n",
    "        reference spectrum has 2 rows (wavelength, calib. amplitude)'''\n",
    "    \n",
    "        _,wave, amp_uncal, amp_cal = object_spectrum\n",
    "        wave_ref,amp_ref = reference_spectrum\n",
    "    \n",
    "        # Median average if requested\n",
    "        amp_uncal = medfilt(amp_uncal,kernel_size = medavg) \n",
    "        amp_cal = medfilt(amp_cal,kernel_size = medavg) \n",
    "    \n",
    "        fig, ((ax1, ax2),(ax3,ax4)) = plt.subplots(2, 2,figsize=(10,8))\n",
    "        plt.suptitle(title)\n",
    "        # Uncalibrated spectrum\n",
    "        ax1.plot(wave, amp_uncal)\n",
    "        ax1.set_xlabel('Wavelength')\n",
    "        ax1.set_ylabel('Uncalibrated amp.')\n",
    "        ax1.set_title('Raw Spectrum')\n",
    "        ax1.grid()\n",
    "\n",
    "        # Gain curve\n",
    "        gain =  self.f_gain(wave_ref)\n",
    "        gain /= np.max(gain)\n",
    "        ax2.plot(wave_ref,gain,'k.',ms=2)\n",
    "        ax2.set_xlabel('Wavelength')\n",
    "        ax2.set_ylabel('Gain')\n",
    "        ax2.set_xlim(380,750)\n",
    "        ax2.set_title('Gain vs. Wavelength')\n",
    "        ax2.grid()\n",
    "\n",
    "        # Calibrated amplitude\n",
    "        ax3.plot(wave, amp_cal)\n",
    "        ax3.set_xlabel('Wavelength')\n",
    "        ax3.set_ylabel('Calibrated amplitude')\n",
    "        ax3.set_xlim(380,750)\n",
    "        ax3.set_title('Calibrated Spectrum')\n",
    "        ax3.grid()\n",
    "\n",
    "        # Reference spectrum\n",
    "        ax4.plot(wave_ref, amp_ref)\n",
    "        ax4.set_xlabel('Wavelength')\n",
    "        ax4.set_ylabel('Calibrated amplitude')\n",
    "        ax4.set_title('Jacoby Spectrum')\n",
    "        ax4.grid()\n",
    "        plt.tight_layout()\n",
    "        return fig\n",
    "\n",
    "    def fit_gaussian(self,spectrum,wave_min,wave_max):\n",
    "        '''Fit a Gaussian function to spectral line in the wavelength range wave_min to wave_max.\n",
    "        Returns fitted parameters with uncertainties and a plot of spectral line and fitted Gaussian'''\n",
    "    \n",
    "        # Constrain spectrum to desired wavelength range, unpack needed arrays\n",
    "        _,wave,_,amp = self.clip_spectrum(spectrum,wave_min,wave_max)\n",
    "    \n",
    "        # Detrend to remove slope\n",
    "        amp = detrend(amp)\n",
    "    \n",
    "        # Find index of max value\n",
    "        imax = np.argmax(np.abs(amp))\n",
    "    \n",
    "        # Fit a Gaussian model\n",
    "        p0 = (wave[imax],amp[imax],2,0,0)\n",
    "        params, pcov = curve_fit(self.__gftn, wave, amp,p0)\n",
    "        wave_ctr, a, fwhm,m,b = params\n",
    "        amp_mod = self.__gftn(wave, *params)\n",
    "    \n",
    "        # Extract uncertainties from covariance\n",
    "        wave_ctr_err, a_err, fwhm_err, _ ,_ = np.abs(np.sqrt(np.diag(pcov)))\n",
    "        f= 2*np.sqrt(2*np.log(2)) *0.5 # sigma -> FWHM factor \n",
    "        fwhm *= f; fwhm_err *= f\n",
    "        fwhm = np.abs(fwhm)\n",
    "        params = (wave_ctr,wave_ctr_err,fwhm,fwhm_err,a,a_err)\n",
    "        return params, wave, amp, amp_mod\n",
    "\n",
    "    def plot_spectral_line(self,wave,amp,amp_mod,color='r',title=''):\n",
    "        fig, ax = plt.subplots(1, 1,figsize=(8,5))\n",
    "        ax.plot(wave,amp_mod,color =color)\n",
    "        ax.plot(wave,amp,'k.')\n",
    "        T = '%s\\n$\\lambda_c$ = %.1f +/- %.1f nm, FWHM = %.1f +/- %.1f nm' % \\\n",
    "            (title,wave_ctr,wave_ctr_err,fwhm,fwhm_err)\n",
    "        plt.suptitle(T)\n",
    "        plt.grid()\n",
    "        return fig\n",
    "    \n",
    "    def __gftn(self,x, x0, a, sigma, m, b):\n",
    "        ''' Define a Gaussian function with a sloping pedestal '''\n",
    "        t = (x-x0) /sigma\n",
    "        f = a*np.exp(-t**2) + m*x + b\n",
    "        return f\n",
    "\n",
    "    def clip_spectrum(self,spectrum, wave_min, wave_max):\n",
    "        '''Restrict wavelength range to avoid crazy gain curve at edges '''\n",
    "        pixel, wave, uncal_amp, cal_amp = spectrum\n",
    "        mask = (wave > wave_min) & (wave < wave_max)\n",
    "        pixel_m = pixel[mask]\n",
    "        wave_m  = wave[mask]\n",
    "        uncal_amp_m   = uncal_amp[mask]\n",
    "        cal_amp_m = cal_amp[mask]\n",
    "        spectrum = np.vstack( [pixel_m, wave_m,uncal_amp_m, cal_amp_m] )\n",
    "        return spectrum\n",
    "    \n",
    "    def plot_spectrum(self, spectrum, xaxis = 'pixel',yaxis = 'uncal', subrange = slice(0,9999), title='', \\\n",
    "        jacoby = False, plot_balmer = False, medavg = 1,xlims =[0,0],ylims =[0,0]):\n",
    "        '''Plots science or Jacoby  spectrum, with selectable axes [x: pixels or wavelength; y: uncalibrated or calibrated. '''\n",
    "        fig, ax = plt.subplots(1,1,figsize=(8, 4))           \n",
    "        fig.suptitle(title) \n",
    "    \n",
    "        if jacoby:\n",
    "            w,c = spectrum\n",
    "            s = subrange\n",
    "            wave = w[s]; amp_cal = c[s]\n",
    "            x = wave    ; ax.set_xlabel('Wavelength [nm]') \n",
    "            y = amp_cal ; ax.set_ylabel('Calibrated amplitude')\n",
    "        else:\n",
    "            # Slice spectrum by selecting user-selected pixel range (Unpythonic!)\n",
    "            p,w,u,c = spectrum\n",
    "            s = subrange\n",
    "            p = p[s] ; w = w[s]; u =u[s]; c = c[s]\n",
    "            spectrum = np.vstack([p,w,u,c])\n",
    "        \n",
    "            pixels, wave, amp_uncal, amp_cal = spectrum\n",
    "            if xaxis == 'pixel':\n",
    "                x = pixels ; ax.set_xlabel('Pixels')\n",
    "            else:\n",
    "                x = wave ; ax.set_xlabel('Wavelength [nm]')\n",
    "            if yaxis == 'uncal':\n",
    "                y = amp_uncal ; ax.set_ylabel('Uncalibrated amplitude')\n",
    "            else:\n",
    "                y = amp_cal   ; ax.set_ylabel('Calibrated amplitude')\n",
    "  \n",
    "        if plot_balmer:\n",
    "            for b in balmer: ax.axvline(x=b,linestyle='dotted')\n",
    "     \n",
    "        # Median average if requested \n",
    "        y = medfilt(y,kernel_size = medavg)  \n",
    "        ax.plot(x,y,'k-')    \n",
    "        if xlims != [0,0]: \n",
    "            xmin,xmax = xlims\n",
    "            ax.set_xlim(xmin,xmax)   \n",
    "        if ylims != [0,0]: \n",
    "            ymin,ymax = ylims\n",
    "            ax.set_ylim(ymin,ymax)\n",
    "        else:\n",
    "            ax.set_ylim(0,np.max(y)*1.1)  \n",
    "        ax.grid()\n",
    "        return fig\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b7b9674c-0c20-40b1-bf52-31ef4c3a11a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_calfile(fname):\n",
    "    ''' Reads grism calibration file (.csv), extracts header line, subimage box, rotation angle, \n",
    "    and coefficients to generate functions that convert pixels to wavelength and gain vs wavelength'''\n",
    "    with open(fname,'r') as f:\n",
    "        lines = f.read().split('\\n')\n",
    "        hdr_line = lines[0]\n",
    "        box = [int(x) for x in lines[1].split(',')]\n",
    "        angle = float(lines[2])\n",
    "        wavelength_coefficients = np.array([float(x) for x in lines[3].split(',')])\n",
    "        gain_coefficients = np.array([float(x) for x in lines[4].split(',')] )    \n",
    "    return(hdr_line, box, angle, wavelength_coefficients, gain_coefficients)\n",
    "\n",
    "def read_jacoby_file(fname):\n",
    "        ''' Reads a standard Jacoby .csv file, packs wavelength and amplitude arrays into spectrum object '''\n",
    "        wave_ref, spec_ref = np.loadtxt(fname, unpack=True, \\\n",
    "        comments='#',usecols=(0,1),dtype = float)\n",
    "        spec_ref /= np.max(spec_ref)\n",
    "        jacoby_spectrum = np.vstack([wave_ref,spec_ref])  # contains wavelength and amp. arrays\n",
    "        return jacoby_spectrum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "desperate-storm",
   "metadata": {},
   "source": [
    "Read science image, calibration file, and corresponding Jacoby spectrum if available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "disciplinary-lightning",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found grism image: /Users/rlmhome/Dropbox/Gemini/Grism/Grism-March2023/Grism-images-2023Mar05/mol0644c.fts\n",
      "Found calibration file: grism_cal_2023_03_01.csv   Grism calibration created 2023/03/01 using , DL Imaging\n",
      "Object: HR5501, Date: 2023-03-05T11:19:52.68\n"
     ]
    }
   ],
   "source": [
    "# Which computer am I using?\n",
    "if os.path.exists('/Users/rlmhome'):\n",
    "    parent = '/Users/rlmhome/'\n",
    "else:\n",
    "    parent = '/Users/rlm/'\n",
    "\n",
    "# Set flag to create a calibration file (cf. calibrating a raw image using an existing cal file)\n",
    "do_calibrate = False\n",
    "    \n",
    "# Specify raw science image  \n",
    "#base_name = 'Dropbox/Gemini/Grism/Grism-March2023/Grism-images-2023Feb27/'\n",
    "#image_name = 'HD20023_1600um_0x0pix.fit'\n",
    "\n",
    "base_name = 'Dropbox/Gemini/Grism/Grism-March2023/Grism-images-2023Mar05/'\n",
    "image_name = 'mol0644c.fts'\n",
    "\n",
    "grism_image = parent + base_name + image_name\n",
    "if os.path.exists(grism_image):\n",
    "    print('Found grism image: %s' % grism_image)\n",
    "    im, hdr = getdata(grism_image, 0, header=True)\n",
    "    object_name  = hdr['OBJECT']\n",
    "    #object_name = 'HD20023' ################### Added because no OBJECT keyword\n",
    "    obs_date = hdr['DATE-OBS']\n",
    "else:\n",
    "    print('Cannot find %s, stopping' % full_image_name)\n",
    "    raise StopExecution  \n",
    "\n",
    "if not do_calibrate:\n",
    "    # Specify an existing calibration file\n",
    "    cal_file = parent + 'Dropbox/Gemini/Grism/Grism-March2023/grism_cal_2023_03_01.csv'\n",
    "    if os.path.exists(cal_file):\n",
    "        cal_hdr, box, rot_angle, wavelength_coefficients, gain_coefficients = read_calfile(cal_file)\n",
    "        f_wave = np.poly1d(wavelength_coefficients)\n",
    "        f_gain = np.poly1d(gain_coefficients)\n",
    "        print('Found calibration file: %s' % os.path.basename(cal_file),' ',cal_hdr)\n",
    "    else:\n",
    "        print('Error: Cannot find calibration file: %s' % cal_file)\n",
    "        raise StopExecution  \n",
    "    \n",
    "# Check for matching Jacoby image\n",
    "jacoby_dir = parent + 'Dropbox/Gemini/Grism/Grism_calibration/Jacoby_spectra/'\n",
    "jacoby_csv = '%s%s-Jacoby-spec.csv' % (jacoby_dir,object_name)\n",
    "if os.path.exists(jacoby_csv): \n",
    "    print('Found matching Jacoby spectrum file: %s' % jacoby_csv)\n",
    "    jacoby = True\n",
    "    jacoby_spectrum = read_jacoby_file(jacoby_csv)\n",
    "else:\n",
    "    jacoby = False\n",
    "    jacoby_spectrum = np.array([])\n",
    "\n",
    "print('Object: %s, Date: %s' % (object_name,obs_date))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ef2eb30-3812-49d9-ba77-c468e8cde522",
   "metadata": {},
   "source": [
    "Allow user to edit subimage box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "harmful-state",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xoffset = 0, yoffset = -365\n",
      "xwidth  = 2000, ywidth = 60\n",
      "Box =  [1048, 3048, 1653, 1713]\n",
      "Full image dimensions: 4096 x 4096\n",
      "Rotation angle = 2.7 deg\n",
      "Sub image dimensions: 60 x 2000\n",
      "Maximum ADU count in subimage = 24964\n",
      "HR5501\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Print nominal box values\n",
    "#xmin,xmax,ymin,ymax = box\n",
    "\n",
    " \n",
    "manual_entry = True\n",
    "# Override calibration values here (nominal values shown)\n",
    "if manual_entry:\n",
    "    rot_angle = 2.7\n",
    "    xs,ys = im.shape\n",
    "    xwidth = 2000\n",
    "    ywidth = 60\n",
    "    yoffset = -365\n",
    "    xoffset = 0\n",
    "    xmin = xs//2 -1000 + xoffset\n",
    "    xmax = xmin + xwidth\n",
    "    \n",
    "    ymin = ys//2 + yoffset - ywidth//2\n",
    "    ymax = ymin + ywidth\n",
    "    mybox  = [xmin,xmax,ymin,ymax]\n",
    "    print('xoffset = %i, yoffset = %i' % (xoffset,yoffset))\n",
    "    print('xwidth  = %i, ywidth = %i' % (xwidth,ywidth))\n",
    "    print('Box = ',mybox)\n",
    "else:\n",
    "    mybox = box\n",
    "    print('Box = ',mybox)\n",
    "xi, yi = im.shape\n",
    "print('Full image dimensions: %i x %i' % (xi,yi))\n",
    "print('Rotation angle = %.1f deg' % rot_angle)\n",
    "\n",
    "# Instantiate with rotation angle and subimage box either from cal file ot user-specified\n",
    "B = grism_utils(grism_image,rot_angle,mybox,f_wave,f_gain)\n",
    "\n",
    "# Create subimage using optional box parameters\n",
    "subim = B.create_subimage()\n",
    "xs,ys = subim.shape\n",
    "print('Sub image dimensions: %i x %i' % (xs,ys))\n",
    "zmax = np.max(subim)\n",
    "print('Maximum ADU count in subimage = %i' % zmax)\n",
    "\n",
    "# Plot subimage\n",
    "object_name, obs_date,telescope,camera,title,im,rot_angle, box, _,_ = B.summary_info()\n",
    "fig = B.plot_image(image=subim,figsize =(10,2),cmap='jet',title=title)\n",
    "print(object_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "special-attitude",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "spectrum = B.calibrate_spectrum(subim)\n",
    "fig = B.plot_spectrum(spectrum, xaxis='pixel', yaxis='uncal', subrange = slice(300,2000),\\\n",
    "                    title='%s Uncalibrated Spectrum' % object_name, medavg = 5,xlims =[0,0],ylims =[-0.1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "powered-committee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = B.plot_spectrum(spectrum, xaxis='wave', yaxis='cal',medavg=7, title='%s Calibrated Spectrum' % object_name,\n",
    "xlims=[400,750],ylims =[0,0],plot_balmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "soviet-plaza",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = B.plot_gain_curve(spectrum,color='r',title='Gain curve')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "closing-breeding",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skipping 2x2 plot (HR5501 is not a Jacoby reference star\n"
     ]
    }
   ],
   "source": [
    "if jacoby:\n",
    "    fig = B.plot_2x2(spectrum, jacoby_spectrum, title=object_name, medavg=5)\n",
    "else:\n",
    "    print('Skipping 2x2 plot (%s is not a Jacoby reference star' % object_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "sensitive-grave",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wave_ctr = 409.4 +/- 0.0 nm, FWHM = 2.1 +/- 0.1 nm\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit a line with Gaussian and  plot\n",
    "wave_min = 400 ; wave_max = 420\n",
    "params, wave, amp, amp_mod = B.fit_gaussian(spectrum,wave_min,wave_max)\n",
    "wave_ctr,wave_ctr_err,fwhm,fwhm_err,a,a_err = params\n",
    "print('Wave_ctr = %.1f +/- %.1f nm, FWHM = %.1f +/- %.1f nm\\n' % (wave_ctr,wave_ctr_err, fwhm, fwhm_err))\n",
    "fig = B.plot_spectral_line(wave,amp,amp_mod,color='red',title=object_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "southern-chapel",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "428706c9-77bb-4752-8d46-7dabb626695f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}