From d864a796ccdfc3c2cbe39dbc4bdea1a3125c6a20 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Thu, 11 Apr 2024 13:23:00 -0700 Subject: [PATCH 01/14] added flat calibartion --- corgidrp/data.py | 42 +++++++++++++++++++++++++++++++++++++++++- corgidrp/l2a_to_l2b.py | 21 ++++++++++++++++++++- 2 files changed, 61 insertions(+), 2 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 8907e5f4..ac7dd4ed 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -424,6 +424,47 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'Dark': raise ValueError("File that was loaded was not a Dark file.") + +class Masterflat(Image): + """ + Master flat generated from raster scan of uranus or Neptune. + + Args: + data_or_filepath (str or np.array): either the filepath to the FITS file to read in OR the 2D image data + pri_hdr (astropy.io.fits.Header): the primary header (required only if raw 2D data is passed in) + ext_hdr (astropy.io.fits.Header): the image extension header (required only if raw 2D data is passed in) + input_dataset (corgidrp.data.Dataset): the Image files combined together to make this dark file (required only if raw 2D data is passed in) + """ + def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=None): + # run the image class contructor + #super().__init__(data_or_filepath, pri_hdr=pri_hdr, ext_hdr=ext_hdr) + # additional bookkeeping for Dark + + # if this is a new dark, we need to bookkeep it in the header + # b/c of logic in the super.__init__, we just need to check this to see if it is a new dark + if ext_hdr is not None: + if input_dataset is None: + # error check. this is required in this case + raise ValueError("This appears to be a new dark. The dataset of input files needs to be passed in to the input_dataset keyword to record history of this dark.") + self.ext_hdr['DATATYPE'] = 'Dark' # corgidrp specific keyword for saving to disk + + # log all the data that went into making this dark + self._record_parent_filenames(input_dataset) + + # add to history + self.ext_hdr['HISTORY'] = "Dark with exptime = {0} s created from {1} frames".format(self.ext_hdr['EXPTIME'], self.ext_hdr['DRPNFILE']) + + # give it a default filename using the first input file as the base + # strip off everything starting at .fits + orig_input_filename = input_dataset[0].filename.split(".fits")[0] + self.filename = "{0}_dark.fits".format(orig_input_filename) + + + # double check that this is actually a dark file that got read in + # since if only a filepath was passed in, any file could have been read in + if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'Dark': + raise ValueError("File that was loaded was not a Dark file.") + class NonLinearityCalibration(Image): """ Class for non-linearity calibration files. Although it's not stricly an image that you might look at, it is a 2D array of data @@ -501,7 +542,6 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'NonLinearityCalibration': raise ValueError("File that was loaded was not a NonLinearityCalibration file.") - datatypes = { "Image" : Image, "Dark" : Dark, "NonLinearityCalibration" : NonLinearityCalibration } diff --git a/corgidrp/l2a_to_l2b.py b/corgidrp/l2a_to_l2b.py index 201a0f40..2fbbafb2 100644 --- a/corgidrp/l2a_to_l2b.py +++ b/corgidrp/l2a_to_l2b.py @@ -115,8 +115,27 @@ def flat_division(input_dataset, master_flat): Returns: corgidrp.data.Dataset: a version of the input dataset with the flat field divided out """ + + # you should make a copy the dataset to start + flatdiv_dataset = input_dataset.copy() + + #Divide by the master flat + flatdiv_cube = flatdiv_dataset.all_data/master_flat.data + + # propagate the error of the master flat frame + if hasattr(master_flat, "err"): + flatdiv_dataset.add_error_term(master_flat.err, "masterflat_error") + else: + raise Warning("no error attribute in the master flat") + + #darksub_dataset.all_err = np.array([frame.err for frame in darksub_dataset.frames]) + history_msg = "Flat calibration done using master_flat".format(master_flat.filename) + + # update the output dataset with this new dark subtracted data and update the history + flatdiv_dataset.update_after_processing_step(history_msg, new_all_data=flatdiv_cube) + + return flatdiv_dataset - return None def correct_bad_pixels(input_dataset): """ From 8077c4ae8f2a01ecfc39e6451b89427082bee47f Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Thu, 11 Apr 2024 13:43:22 -0700 Subject: [PATCH 02/14] flat calibration --- corgidrp/data.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index ac7dd4ed..eb41635d 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -445,8 +445,8 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N if ext_hdr is not None: if input_dataset is None: # error check. this is required in this case - raise ValueError("This appears to be a new dark. The dataset of input files needs to be passed in to the input_dataset keyword to record history of this dark.") - self.ext_hdr['DATATYPE'] = 'Dark' # corgidrp specific keyword for saving to disk + raise ValueError("This appears to be a master flat. The dataset of input files needs to be passed in to the input_dataset keyword to record history of this flat") + self.ext_hdr['DATATYPE'] = 'Masterflat' # corgidrp specific keyword for saving to disk # log all the data that went into making this dark self._record_parent_filenames(input_dataset) From 85a44e3deb51355560a0eb675c304920f794ac5c Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Fri, 12 Apr 2024 16:12:03 -0700 Subject: [PATCH 03/14] flat calibration updated --- corgidrp/data.py | 20 ++++++++++---------- corgidrp/detector.py | 21 +++++++++++++++++++++ corgidrp/l2a_to_l2b.py | 17 ++++++++--------- 3 files changed, 39 insertions(+), 19 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index eb41635d..3298862b 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -433,37 +433,36 @@ class Masterflat(Image): data_or_filepath (str or np.array): either the filepath to the FITS file to read in OR the 2D image data pri_hdr (astropy.io.fits.Header): the primary header (required only if raw 2D data is passed in) ext_hdr (astropy.io.fits.Header): the image extension header (required only if raw 2D data is passed in) - input_dataset (corgidrp.data.Dataset): the Image files combined together to make this dark file (required only if raw 2D data is passed in) + input_dataset (corgidrp.data.Dataset): the Image files combined together to make this flat file (required only if raw 2D data is passed in) """ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=None): # run the image class contructor #super().__init__(data_or_filepath, pri_hdr=pri_hdr, ext_hdr=ext_hdr) - # additional bookkeeping for Dark - # if this is a new dark, we need to bookkeep it in the header - # b/c of logic in the super.__init__, we just need to check this to see if it is a new dark + # if this is a new master flat, we need to bookkeep it in the header + # b/c of logic in the super.__init__, we just need to check this to see if it is a new masterflat if ext_hdr is not None: if input_dataset is None: # error check. this is required in this case raise ValueError("This appears to be a master flat. The dataset of input files needs to be passed in to the input_dataset keyword to record history of this flat") self.ext_hdr['DATATYPE'] = 'Masterflat' # corgidrp specific keyword for saving to disk - # log all the data that went into making this dark + # log all the data that went into making this flat self._record_parent_filenames(input_dataset) # add to history - self.ext_hdr['HISTORY'] = "Dark with exptime = {0} s created from {1} frames".format(self.ext_hdr['EXPTIME'], self.ext_hdr['DRPNFILE']) + #self.ext_hdr['HISTORY'] = "Flat with exptime = {0} s created from {1} frames".format(self.ext_hdr['EXPTIME'], self.ext_hdr['DRPNFILE']) # give it a default filename using the first input file as the base # strip off everything starting at .fits orig_input_filename = input_dataset[0].filename.split(".fits")[0] - self.filename = "{0}_dark.fits".format(orig_input_filename) + self.filename = "{0}_masterflat.fits".format(orig_input_filename) - # double check that this is actually a dark file that got read in + # double check that this is actually a masterflat file that got read in # since if only a filepath was passed in, any file could have been read in - if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'Dark': - raise ValueError("File that was loaded was not a Dark file.") + if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'Masterflat': + raise ValueError("File that was loaded was not a Master flat file.") class NonLinearityCalibration(Image): """ @@ -544,6 +543,7 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N datatypes = { "Image" : Image, "Dark" : Dark, + "Masterflat" : Masterflat, "NonLinearityCalibration" : NonLinearityCalibration } def autoload(filepath): diff --git a/corgidrp/detector.py b/corgidrp/detector.py index 43dc45e3..87594034 100644 --- a/corgidrp/detector.py +++ b/corgidrp/detector.py @@ -26,6 +26,27 @@ def create_dark_calib(dark_dataset): return new_dark +def create_master_flat(flat_dataset): + """ + Turn this dataset of image frames that were taken for performing the flat calibration and + to make one master flat image + + Args: + flat_dataset (corgidrp.data.Dataset): a dataset of Image frames (L2a-level) + + Returns: + data.masterflat: a master flat for flat calibration + """ + combined_frame = np.nanmean(flat_dataset.all_data, axis=0) + + master_flat = data.Masterflat(combined_frame, pri_hdr=flat_dataset[0].pri_hdr.copy(), + ext_hdr=flat_dataset[0].ext_hdr.copy(), input_dataset=flat_dataset) + + # determine the standard error of the mean: stddev/sqrt(n_frames) + master_flat.err = np.nanstd(flat_dataset.all_data, axis=0) + + return master_flat + def get_relgains(frame, em_gain, non_lin_correction): """ For a given bias subtracted frame of dn counts, return a same sized diff --git a/corgidrp/l2a_to_l2b.py b/corgidrp/l2a_to_l2b.py index 2fbbafb2..73f064f5 100644 --- a/corgidrp/l2a_to_l2b.py +++ b/corgidrp/l2a_to_l2b.py @@ -116,25 +116,24 @@ def flat_division(input_dataset, master_flat): corgidrp.data.Dataset: a version of the input dataset with the flat field divided out """ - # you should make a copy the dataset to start - flatdiv_dataset = input_dataset.copy() + # copy of the dataset + flatcal_dataset = input_dataset.copy() #Divide by the master flat - flatdiv_cube = flatdiv_dataset.all_data/master_flat.data + flatcal_cube = flatcal_dataset.all_data/master_flat.data - # propagate the error of the master flat frame + # propagate the error of the master flat frame # Check this error prop if hasattr(master_flat, "err"): - flatdiv_dataset.add_error_term(master_flat.err, "masterflat_error") + flatcal_dataset.add_error_term(master_flat.err, "masterflat_error") else: raise Warning("no error attribute in the master flat") - #darksub_dataset.all_err = np.array([frame.err for frame in darksub_dataset.frames]) history_msg = "Flat calibration done using master_flat".format(master_flat.filename) - # update the output dataset with this new dark subtracted data and update the history - flatdiv_dataset.update_after_processing_step(history_msg, new_all_data=flatdiv_cube) + # update the output dataset with this new flat calibrated data and update the history + flatcal_dataset.update_after_processing_step(history_msg, new_all_data=flatcal_cube) - return flatdiv_dataset + return flatcal_dataset def correct_bad_pixels(input_dataset): From 92eb3f123b7123df3e312d16d9b05907b20dd865 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Tue, 14 May 2024 20:53:00 -0700 Subject: [PATCH 04/14] flat calibration --- corgidrp/data.py | 2 +- corgidrp/detector.py | 2 +- corgidrp/l2a_to_l2b.py | 62 ++++++++++++++++++++++-------------------- corgidrp/mocks.py | 30 ++++++++++++++++++++ 4 files changed, 64 insertions(+), 32 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 3298862b..9cc530ab 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -451,7 +451,7 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N self._record_parent_filenames(input_dataset) # add to history - #self.ext_hdr['HISTORY'] = "Flat with exptime = {0} s created from {1} frames".format(self.ext_hdr['EXPTIME'], self.ext_hdr['DRPNFILE']) + self.ext_hdr['HISTORY'] = "Flat with exptime = {0} s created from {1} frames".format(self.ext_hdr['EXPTIME'], self.ext_hdr['DRPNFILE']) # give it a default filename using the first input file as the base # strip off everything starting at .fits diff --git a/corgidrp/detector.py b/corgidrp/detector.py index 87594034..840f26c2 100644 --- a/corgidrp/detector.py +++ b/corgidrp/detector.py @@ -43,7 +43,7 @@ def create_master_flat(flat_dataset): ext_hdr=flat_dataset[0].ext_hdr.copy(), input_dataset=flat_dataset) # determine the standard error of the mean: stddev/sqrt(n_frames) - master_flat.err = np.nanstd(flat_dataset.all_data, axis=0) + master_flat.err = np.nanstd(flat_dataset.all_data, axis=0)/np.sqrt(len(flat_dataset)) return master_flat diff --git a/corgidrp/l2a_to_l2b.py b/corgidrp/l2a_to_l2b.py index 73f064f5..5d822951 100644 --- a/corgidrp/l2a_to_l2b.py +++ b/corgidrp/l2a_to_l2b.py @@ -58,6 +58,38 @@ def dark_subtraction(input_dataset, dark_frame): return darksub_dataset +def flat_division(input_dataset, master_flat): + """ + + Divide the dataset by the master flat field. + + Args: + input_dataset (corgidrp.data.Dataset): a dataset of Images (L2a-level) + master_flat (corgidrp.data.Flat): a master flat field to divide by + + Returns: + corgidrp.data.Dataset: a version of the input dataset with the flat field divided out + """ + + # copy of the dataset + flatcal_dataset = input_dataset.copy() + + #Divide by the master flat + flatcal_cube = flatcal_dataset.all_data/master_flat.data + + # propagate the error of the master flat frame # Check this error prop + if hasattr(master_flat, "err"): + flatcal_dataset.add_error_term(master_flat.err, "masterflat_error") + else: + raise Warning("no error attribute in the master flat") + + history_msg = "Flat calibration done using master_flat".format(master_flat.filename) + + # update the output dataset with this new flat calibrated data and update the history + flatcal_dataset.update_after_processing_step(history_msg, new_all_data=flatcal_cube) + + return flatcal_dataset + def frame_select(input_dataset): """ @@ -103,37 +135,7 @@ def cti_correction(input_dataset): return None -def flat_division(input_dataset, master_flat): - """ - - Divide the dataset by the master flat field. - - Args: - input_dataset (corgidrp.data.Dataset): a dataset of Images (L2a-level) - master_flat (corgidrp.data.Flat): a master flat field to divide by - Returns: - corgidrp.data.Dataset: a version of the input dataset with the flat field divided out - """ - - # copy of the dataset - flatcal_dataset = input_dataset.copy() - - #Divide by the master flat - flatcal_cube = flatcal_dataset.all_data/master_flat.data - - # propagate the error of the master flat frame # Check this error prop - if hasattr(master_flat, "err"): - flatcal_dataset.add_error_term(master_flat.err, "masterflat_error") - else: - raise Warning("no error attribute in the master flat") - - history_msg = "Flat calibration done using master_flat".format(master_flat.filename) - - # update the output dataset with this new flat calibrated data and update the history - flatcal_dataset.update_after_processing_step(history_msg, new_all_data=flatcal_cube) - - return flatcal_dataset def correct_bad_pixels(input_dataset): diff --git a/corgidrp/mocks.py b/corgidrp/mocks.py index d88b4e1e..f6327dc4 100644 --- a/corgidrp/mocks.py +++ b/corgidrp/mocks.py @@ -35,6 +35,36 @@ def create_dark_calib_files(filedir=None, numfiles=10): dataset = data.Dataset(frames) return dataset +def create_flat_calib_files(filedir=None, numfiles=10): + """ + Create simulated data to create a master flat. + Assume these have already undergone L1 processing and are L2a level products + + Args: + filedir (str): (Optional) Full path to directory to save to. + numfiles (int): Number of files in dataset. Defaults to 10. + + Returns: + corgidrp.data.Dataset: + The simulated dataset + """ + # Make filedir if it does not exist + if (filedir is not None) and (not os.path.exists(filedir)): + os.mkdir(filedir) + + filepattern = "simcal_flat_{0:04d}.fits" + frames = [] + for i in range(numfiles): + prihdr, exthdr = create_default_headers() + # generate images in normal distribution with mean 1 and std 0.01 + np.random.seed(456+i); sim_data = np.random.normal(loc=1.0, scale=0.01, size=(1024, 1024)) + frame = data.Image(sim_data, pri_hdr=prihdr, ext_hdr=exthdr) + if filedir is not None: + frame.save(filedir=filedir, filename=filepattern.format(i)) + frames.append(frame) + dataset = data.Dataset(frames) + return dataset + def create_nonlinear_dataset(filedir=None, numfiles=2,em_gain=2000): """ Create simulated data to non-linear data to test non-linearity correction. From bd6017f54cee05ce39a24daa72e1d470c475ce9b Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Wed, 22 May 2024 10:36:23 -0700 Subject: [PATCH 05/14] flat calibration --- tests/demo_test_flatcal.ipynb | 283 ++++++++++++++++++++++++++++++++++ tests/test_flat_div.py | 64 ++++++++ 2 files changed, 347 insertions(+) create mode 100644 tests/demo_test_flatcal.ipynb create mode 100644 tests/test_flat_div.py diff --git a/tests/demo_test_flatcal.ipynb b/tests/demo_test_flatcal.ipynb new file mode 100644 index 00000000..ee16c13e --- /dev/null +++ b/tests/demo_test_flatcal.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "0f851ced-af53-4c35-9349-4a83892e5fb9", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import glob\n", + "import pytest\n", + "import numpy as np\n", + "import corgidrp.data as data\n", + "import corgidrp.mocks as mocks\n", + "import corgidrp.detector as detector\n", + "import corgidrp.l2a_to_l2b as l2a_to_l2b\n", + "import astropy.io.fits as fits\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "972a2e50-8c00-4146-a54e-3003cce56e98", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8fa54a94-53f6-4750-be73-e57e133c5fd8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Generate mock input data and pass into flat division function\n", + "\"\"\"\n", + "###### create simulated data\n", + "# check that simulated data folder exists, and create if not\n", + "datadir = os.path.join(os.path.dirname('test'), \"simflatdata\")\n", + "if not os.path.exists(datadir):\n", + " os.mkdir(datadir)\n", + " \n", + "mocks.create_flat_calib_files(filedir=datadir)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8a5aa62a-fb80-4dc0-bc5f-8140e60a3ec6", + "metadata": {}, + "outputs": [], + "source": [ + "####### test data architecture \n", + "### check if there are 10 files\n", + "flat_filenames = glob.glob(os.path.join(datadir, \"simcal_flat*.fits\"))\n", + "\n", + "flat_dataset = data.Dataset(flat_filenames)\n", + "\n", + "assert len(flat_dataset) == 10" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5223f95f-f714-43df-a9a7-dd7607781ffe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max values of the images = [1.0521428105741673, 1.050312922010232, 1.0492989900622829, 1.050316396577612, 1.050250963841579, 1.0503468907652613, 1.0491359411678376, 1.0503906727399142, 1.0490298758429357, 1.0518204225439023]\n", + "Min values of the images = [0.9496408003531838, 0.9522178641427266, 0.9541035663502095, 0.9492359087008593, 0.9525005602288115, 0.950245494099894, 0.9506716478703111, 0.9527782734528316, 0.9513474231457663, 0.9481027111929206]\n", + "Std values of the images = [0.010000943722629316, 0.01000124518834392, 0.009988944326694837, 0.009997227223346521, 0.010001980313383504, 0.009999392143117326, 0.01000445288947456, 0.009992061821400519, 0.00999901140824875, 0.01000051146739932]\n" + ] + } + ], + "source": [ + "# display the ten images that are used for creating flat\n", + "im_max_array=[]; im_min_array=[]; im_std_array=[];\n", + "for i in range(0,10):\n", + " im=fits.getdata(flat_filenames[i])\n", + " im_max=np.max(im)\n", + " im_min=np.min(im)\n", + " im_std=np.std(im)\n", + " im_max_array.append(im_max)\n", + " im_min_array.append(im_min)\n", + " im_std_array.append(im_std)\n", + "print(\"Max values of the images =\", im_max_array) \n", + "print(\"Min values of the images =\", im_min_array) \n", + "print(\"Std values of the images =\", im_std_array) " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "65012ff8-28d1-436d-ad32-cc581a29a52d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig=plt.figure(dpi=100)\n", + "ax2=plt.subplot(111)\n", + "im2=ax2.imshow(flat_dataset[0].data,cmap='viridis')\n", + "ax2.invert_yaxis()\n", + "ax2.set_ylabel('y [pixels]')\n", + "ax2.set_xlabel('x [pixels]')\n", + "ax2.set_title('Flat dataset [0]')\n", + "cb=plt.colorbar(im2,orientation='vertical')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "34a20c46-027b-4f16-b474-e2897e77d9f7", + "metadata": {}, + "outputs": [], + "source": [ + "# check that data is consistently modified\n", + "flat_dataset.all_data[0,0,0] = 1\n", + "assert flat_dataset[0].data[0,0] == 1\n", + " \n", + "flat_dataset[0].data[0,0] = 1\n", + "assert flat_dataset.all_data[0,0,0] == 1\n", + "\n", + "###### create master flat\n", + "flat_frame = detector.create_master_flat(flat_dataset)\n", + " \n", + " \n", + "# check that the error is determined correctly\n", + "assert np.array_equal(np.std(flat_dataset.all_data, axis = 0)/np.sqrt(len(flat_dataset)), flat_frame.err)\n", + " \n", + "# save flat\n", + "calibdir = os.path.join(os.path.dirname('test'), \"testcalib\")\n", + "flat_filename = \"sim_flat_calib.fits\"\n", + "if not os.path.exists(calibdir):\n", + " os.mkdir(calibdir)\n", + " flat_frame.save(filedir=calibdir, filename=flat_filename) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3793d90e-2239-46c4-b9dc-cec15343989a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b69b975d-fee6-495a-b41d-f06facc6e575", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig=plt.figure(dpi=100)\n", + "ax2=plt.subplot(111)\n", + "im2=ax2.imshow(flat_frame.data,cmap='viridis')\n", + "ax2.invert_yaxis()\n", + "ax2.set_ylabel('y [pixels]')\n", + "ax2.set_xlabel('x [pixels]')\n", + "ax2.set_title('Master Flat')\n", + "cb=plt.colorbar(im2,orientation='vertical')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d46e7cd1-efa1-4a60-98c4-24ee48513625", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean of all data: 1.0\n", + "mean of all errors: 0.0029173101230186333\n", + "XTENSION= 'IMAGE ' / Image extension BITPIX = -64 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 1024 NAXIS2 = 1024 PCOUNT = 0 / number of parameters GCOUNT = 1 / number of groups ARRTYPE = 'SCI ' SCTSRT = '2024-01-01T12:00:00.000Z' SCTEND = '2024-01-01T20:00:00.000Z' STATUS = 0 HVCBIAS = 1 OPMODE = '' EXPTIME = 60.0 CMDGAIN = 1.0 CYCLES = 100000000000 LASTEXP = 1000000 BLNKTIME= 10 EXPCYC = 100 OVEREXP = 0 NOVEREXP= 0 EXCAMT = 40.0 FCMLOOP = '' FSMINNER= '' FSMLOS = '' FSM_X = 50.0 FSM_Y = 50.0 DMZLOOP = '' SPAM_H = 1.0 SPAM_V = 1.0 FPAM_H = 1.0 FPAM_V = 1.0 LSAM_H = 1.0 LSAM_V = 1.0 FSAM_H = 1.0 FSAM_V = 1.0 CFAM_H = 1.0 CFAM_V = 1.0 DPAM_H = 1.0 DPAM_V = 1.0 DATETIME= '2024-01-01T11:00:00.000Z' HIERARCH DATA_LEVEL = 'L1 ' MISSING = F DRPVERSN= '0.1 ' / corgidrp version that produced this file DRPCTIME= '2024-05-22T17:26:54.129' / When this file was saved HISTORY Flat calibration done using master_flat END \n" + ] + } + ], + "source": [ + "###### perform flat division\n", + "# load in the masterflat\n", + "flat_filepath = os.path.join(calibdir, flat_filename)\n", + "new_masterflat = data.Masterflat(flat_filepath)\n", + "# divide sim_data from masterflat\n", + "flat_dataset = l2a_to_l2b.flat_division(flat_dataset, new_masterflat)\n", + "#assert(flat_filename in str(flat_dataset[0].ext_hdr[\"HISTORY\"]))\n", + "\n", + "# check the level of the dataset is now approximately 0 \n", + "assert np.mean(flat_dataset.all_data) == pytest.approx(1, abs=1e-2)\n", + "# check the propagated errors\n", + "assert flat_dataset[0].err_hdr[\"Layer_2\"] == \"masterflat_error\"\n", + "assert(np.mean(flat_dataset.all_err) == pytest.approx(np.mean(flat_frame.err), abs = 1e-2))\n", + "print(\"mean of all data:\", np.mean(flat_dataset.all_data))\n", + "print(\"mean of all errors:\", np.mean(flat_dataset.all_err))\n", + "print(flat_dataset[0].ext_hdr)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d32e4ed2-0eab-45eb-b7d3-38925bdf03c6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fda91da1-004a-4ed7-bf18-a901787c3eb4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ffe4fce4-1fab-49c7-b7ad-2a7fb0b754c9", + "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 +} diff --git a/tests/test_flat_div.py b/tests/test_flat_div.py new file mode 100644 index 00000000..a85849b0 --- /dev/null +++ b/tests/test_flat_div.py @@ -0,0 +1,64 @@ +import os +import glob +import pytest +import numpy as np +import corgidrp.data as data +import corgidrp.mocks as mocks +import corgidrp.detector as detector +import corgidrp.l2a_to_l2b as l2a_to_l2b + +def test_flat_div(): + + """ + Generate mock input data and pass into flat division function + """ + ###### create simulated data + # check that simulated data folder exists, and create if not + datadir = os.path.join(os.path.dirname(__file__), "simflatdata") + if not os.path.exists(datadir): + os.mkdir(datadir) + + mocks.create_flat_calib_files(filedir=datadir) + + flat_filenames = glob.glob(os.path.join(datadir, "simcal_flat*.fits")) + + flat_dataset = data.Dataset(flat_filenames) + + assert len(flat_dataset) == 10 + + + + ###### create master flat + flat_frame = detector.create_master_flat(flat_dataset) + + + # check that the error is determined correctly + assert np.array_equal(np.std(flat_dataset.all_data, axis = 0)/np.sqrt(len(flat_dataset)), flat_frame.err) + + # save flat + calibdir = os.path.join(os.path.dirname('test'), "testcalib") + flat_filename = "sim_flat_calib.fits" + if not os.path.exists(calibdir): + os.mkdir(calibdir) + flat_frame.save(filedir=calibdir, filename=flat_filename) + + ###### perform flat division + # load in the masterflat + flat_filepath = os.path.join(calibdir, flat_filename) + new_masterflat = data.Masterflat(flat_filepath) + # divide sim_data from masterflat + flat_dataset = l2a_to_l2b.flat_division(flat_dataset, new_masterflat) + #assert(flat_filename in str(flat_dataset[0].ext_hdr["HISTORY"])) + + # check the level of the dataset is now approximately 0 + assert np.mean(flat_dataset.all_data) == pytest.approx(1, abs=1e-2) + # check the propagated errors + assert flat_dataset[0].err_hdr["Layer_2"] == "masterflat_error" + assert(np.mean(flat_dataset.all_err) == pytest.approx(np.mean(flat_frame.err), abs = 1e-2)) + print("mean of all data:", np.mean(flat_dataset.all_data)) + print("mean of all errors:", np.mean(flat_dataset.all_err)) + print(flat_dataset[0].ext_hdr) + + +if __name__ == "__main__": + test_flat_div() \ No newline at end of file From 2f2d4ab52d566bfc31b067228f532d6b82ce50ae Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Wed, 22 May 2024 10:50:28 -0700 Subject: [PATCH 06/14] flat calibration --- corgidrp/data.py | 3 +-- tests/test_flat_div.py | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 9cc530ab..3abd59a1 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -437,7 +437,7 @@ class Masterflat(Image): """ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=None): # run the image class contructor - #super().__init__(data_or_filepath, pri_hdr=pri_hdr, ext_hdr=ext_hdr) + super().__init__(data_or_filepath, pri_hdr=pri_hdr, ext_hdr=ext_hdr) # if this is a new master flat, we need to bookkeep it in the header # b/c of logic in the super.__init__, we just need to check this to see if it is a new masterflat @@ -454,7 +454,6 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N self.ext_hdr['HISTORY'] = "Flat with exptime = {0} s created from {1} frames".format(self.ext_hdr['EXPTIME'], self.ext_hdr['DRPNFILE']) # give it a default filename using the first input file as the base - # strip off everything starting at .fits orig_input_filename = input_dataset[0].filename.split(".fits")[0] self.filename = "{0}_masterflat.fits".format(orig_input_filename) diff --git a/tests/test_flat_div.py b/tests/test_flat_div.py index a85849b0..b3538109 100644 --- a/tests/test_flat_div.py +++ b/tests/test_flat_div.py @@ -16,7 +16,7 @@ def test_flat_div(): # check that simulated data folder exists, and create if not datadir = os.path.join(os.path.dirname(__file__), "simflatdata") if not os.path.exists(datadir): - os.mkdir(datadir) + os.mkdir(datadir) mocks.create_flat_calib_files(filedir=datadir) @@ -40,7 +40,7 @@ def test_flat_div(): flat_filename = "sim_flat_calib.fits" if not os.path.exists(calibdir): os.mkdir(calibdir) - flat_frame.save(filedir=calibdir, filename=flat_filename) + flat_frame.save(filedir=calibdir, filename=flat_filename) ###### perform flat division # load in the masterflat From 110714d6e4cf7c1b5119131cd4ba5831e3e52629 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Wed, 22 May 2024 11:01:43 -0700 Subject: [PATCH 07/14] Update data.py --- corgidrp/data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index d088af60..8eb775ca 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -596,7 +596,7 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N # since if only a filepath was passed in, any file could have been read in if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'NonLinearityCalibration': raise ValueError("File that was loaded was not a NonLinearityCalibration file.") -======= + class BadPixelMap(Image): """ Class for bad pixel map. The bad pixel map indicates which pixels are hot From a8c5c1352a23ee49e2b25498b6cca28f5796a0ad Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Wed, 22 May 2024 11:05:22 -0700 Subject: [PATCH 08/14] Update data.py --- corgidrp/data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 8eb775ca..0d532d5f 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -642,7 +642,7 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N datatypes = { "Image" : Image, "Dark" : Dark, "NonLinearityCalibration" : NonLinearityCalibration, - "BadPixelMap" : BadPixelMap + "BadPixelMap" : BadPixelMap, "Masterflat" : Masterflat} From 4c4d49f6dd3b54d638ad423c8863493d7127bfa1 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Tue, 11 Jun 2024 10:51:47 -0700 Subject: [PATCH 09/14] fixed errors in build --- corgidrp/data.py | 184 +++++++++++++++++++++++++++++++++++++++-- corgidrp/detector.py | 20 +++-- corgidrp/l2a_to_l2b.py | 49 ++++++----- corgidrp/mocks.py | 43 ++++++++-- tests/test_flat_div.py | 91 ++++++++++++-------- 5 files changed, 309 insertions(+), 78 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 0d532d5f..e71693ee 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -158,7 +158,34 @@ def add_error_term(self, input_error, err_name): self.all_err = np.array([frame.err for frame in self.frames]) for i, frame in enumerate(self.frames): frame.err = self.all_err[i] + + + def rescale_error(self, input_error, err_name): + """ + Calls Image.rescale_errors() for each frame. + Updates Dataset.all_err + + Args: + input_error (np.array): 2-d error layer or 3-d layer + err_name (str): name of the uncertainty layer + """ + if input_error.ndim == 3: + for i,frame in enumerate(self.frames): + frame.rescale_error(input_error[i], err_name) + elif input_error.ndim ==2: + for frame in self.frames: + frame.rescale_error(input_error, err_name) + + else: + raise ValueError("input_error is not either a 2D or 3D array.") + + # Preserve pointer links between Dataset.all_err and Image.err + self.all_err = np.array([frame.err for frame in self.frames]) + for i, frame in enumerate(self.frames): + frame.err = self.all_err[i] + + class Image(): """ Base class for 2-D image data. Data can be created by passing in the data/header explicitly, or @@ -430,6 +457,38 @@ def add_error_term(self, input_error, err_name): #first layer is always the updated combined error self.err[0,:,:] = np.sqrt(self.err[0,:,:]**2 + input_error**2) self.err_hdr["Layer_1"] = "combined_error" + self.err_hdr["Layer_" + layer] = err_name + + def rescale_error(self, input_error, err_name): + """ + Add a layer of a specific additive uncertainty on the 3-dim error array extension + and update the combined uncertainty in the first layer. + Update the error header and assign the error name. + + Only tracks individual errors if the "track_individual_errors" setting is set to True + in the configuration file + + Args: + input_error (np.array): 2-d error layer + err_name (str): name of the uncertainty layer + """ + if input_error.ndim != 2 or input_error.shape != self.data.shape: + raise ValueError("we expect a 2-dimensional error layer with dimensions {0}".format(self.data.shape)) + + #first layer is always the updated combined error + self.err = np.sqrt(self.err**2 * input_error**2) + self.err_hdr["Layer_1"] = "combined_error" + + if corgidrp.track_individual_errors: + #append new error as layer on 3D cube + self.err=np.append(self.err, [input_error], axis=0) + + layer = str(self.err.shape[0]) + self.err_hdr["Layer_1"] = "combined_error" + self.err_hdr["Layer_" + layer] = err_name + + # record history since 2-D error map doesn't track individual terms + self.err_hdr['HISTORY'] = "rescaled error term: {0}".format(err_name) if corgidrp.track_individual_errors: #append new error as layer on 3D cube @@ -482,7 +541,7 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N raise ValueError("File that was loaded was not a Dark file.") -class Masterflat(Image): +class FlatField(Image): """ Master flat generated from raster scan of uranus or Neptune. @@ -502,7 +561,7 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N if input_dataset is None: # error check. this is required in this case raise ValueError("This appears to be a master flat. The dataset of input files needs to be passed in to the input_dataset keyword to record history of this flat") - self.ext_hdr['DATATYPE'] = 'Masterflat' # corgidrp specific keyword for saving to disk + self.ext_hdr['DATATYPE'] = 'FlatField' # corgidrp specific keyword for saving to disk # log all the data that went into making this flat self._record_parent_filenames(input_dataset) @@ -512,14 +571,14 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N # give it a default filename using the first input file as the base orig_input_filename = input_dataset[0].filename.split(".fits")[0] - self.filename = "{0}_masterflat.fits".format(orig_input_filename) + self.filename = "{0}_flatfield.fits".format(orig_input_filename) # double check that this is actually a masterflat file that got read in # since if only a filepath was passed in, any file could have been read in - if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'Masterflat': - raise ValueError("File that was loaded was not a Master flat file.") - + if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'FlatField': + raise ValueError("File that was loaded was not a FlatField file.") + class NonLinearityCalibration(Image): """ Class for non-linearity calibration files. Although it's not stricly an image that you might look at, it is a 2D array of data @@ -596,7 +655,86 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N # since if only a filepath was passed in, any file could have been read in if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'NonLinearityCalibration': raise ValueError("File that was loaded was not a NonLinearityCalibration file.") - + +class KGain(Image): + """ + Class for KGain calibration file. Until further insights it is just one float value. + + Args: + data_or_filepath (str or np.array): either the filepath to the FITS file to read in OR the calibration data. See above for the required format. + pri_hdr (astropy.io.fits.Header): the primary header (required only if raw data is passed in) + ext_hdr (astropy.io.fits.Header): the image extension header (required only if raw data is passed in) + + Attrs: + value: the getter of the kgain value + _kgain (float): the value of kgain + """ + def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None): + # run the image class contructor + super().__init__(data_or_filepath, pri_hdr=pri_hdr, ext_hdr=ext_hdr) + + # File format checks + if self.data.shape != (1,1): + raise ValueError('The KGain calibration data should be just one float value') + # run the image class contructor + super().__init__(data_or_filepath, pri_hdr=pri_hdr, ext_hdr=ext_hdr) + + # File format checks + if self.data.shape != (1,1): + raise ValueError('The KGain calibration data should be just one float value') + + self._kgain = self.data[0,0] + # additional bookkeeping for a calibration file + # if this is a new calibration file, we need to bookkeep it in the header + # b/c of logic in the super.__init__, we just need to check this to see if it is a new KGain file + if ext_hdr is not None: + self.ext_hdr['DATATYPE'] = 'KGain' # corgidrp specific keyword for saving to disk + self.ext_hdr['BUNIT'] = 'detected EM electrons/DN' + # add to history + self.ext_hdr['HISTORY'] = "KGain Calibration file created" + + # give it a default filename + self.filename = "KGain.fits" + + + # double check that this is actually a KGain file that got read in + # since if only a filepath was passed in, any file could have been read in + if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'KGain': + raise ValueError("File that was loaded was not a KGain Calibration file.") + + @property + def value(self): + return self._kgain + + def copy(self, copy_data = True): + """ + Make a copy of this KGain file. including data and headers. + Data copying can be turned off if you only want to modify the headers + Headers should always be copied as we should modify them any time we make new edits to the data + + Args: + copy_data (bool): (optional) whether the data should be copied. Default is True + + Returns: + corgidrp.data.KGain: a copy of this KGain + """ + if copy_data: + new_data = np.copy(self.data) + else: + new_data = self.data # this is just pointer referencing + new_kg = KGain(new_data, pri_hdr=self.pri_hdr.copy(), ext_hdr=self.ext_hdr.copy()) + + # annoying, but we got to manually update some parameters. Need to keep track of which ones to update + new_kg.filename = self.filename + new_kg.filedir = self.filedir + + # update DRP version tracking + self.ext_hdr['DRPVERSN'] = corgidrp.version + self.ext_hdr['DRPCTIME'] = time.Time.now().isot + + return new_kg + + class BadPixelMap(Image): """ Class for bad pixel map. The bad pixel map indicates which pixels are hot @@ -639,12 +777,40 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'BadPixelMap': raise ValueError("File that was loaded was not a BadPixelMap file.") + def copy(self, copy_data = True): + """ + Make a copy of this BadPixelMap file. including data and headers. + Data copying can be turned off if you only want to modify the headers + Headers should always be copied as we should modify them any time we make new edits to the data + + Args: + copy_data (bool): (optional) whether the data should be copied. Default is True + + Returns: + corgidrp.data.BadPixelMap: a copy of this BadPixelMap + """ + if copy_data: + new_data = np.copy(self.data) + else: + new_data = self.data # this is just pointer referencing + new_bp = BadPixelMap(new_data, pri_hdr=self.pri_hdr.copy(), ext_hdr=self.ext_hdr.copy()) + + # we got to manually update some parameters. Need to keep track of which ones to update + new_bp.filename = self.filename + new_bp.filedir = self.filedir + + # update DRP version tracking + self.ext_hdr['DRPVERSN'] = corgidrp.version + self.ext_hdr['DRPCTIME'] = time.Time.now().isot + + return new_bp + datatypes = { "Image" : Image, "Dark" : Dark, "NonLinearityCalibration" : NonLinearityCalibration, + "KGain" : KGain, "BadPixelMap" : BadPixelMap, - "Masterflat" : Masterflat} - + "FlatField" :FlatField} def autoload(filepath): """ diff --git a/corgidrp/detector.py b/corgidrp/detector.py index a2812c15..2b50b706 100644 --- a/corgidrp/detector.py +++ b/corgidrp/detector.py @@ -27,26 +27,32 @@ def create_dark_calib(dark_dataset): return new_dark -def create_master_flat(flat_dataset): +def create_flatfield(flat_dataset): + """ Turn this dataset of image frames that were taken for performing the flat calibration and to make one master flat image + this is currently a placeholder, until the final flat fielding calibration package is completed. Args: - flat_dataset (corgidrp.data.Dataset): a dataset of Image frames (L2a-level) + flat_dataset (corgidrp.data.Dataset): a dataset of Image frames (L2a-level) Returns: data.masterflat: a master flat for flat calibration - """ + """ + + combined_frame = np.nanmean(flat_dataset.all_data, axis=0) - master_flat = data.Masterflat(combined_frame, pri_hdr=flat_dataset[0].pri_hdr.copy(), + flat_field = data.FlatField(combined_frame, pri_hdr=flat_dataset[0].pri_hdr.copy(), ext_hdr=flat_dataset[0].ext_hdr.copy(), input_dataset=flat_dataset) - # determine the standard error of the mean: stddev/sqrt(n_frames) - master_flat.err = np.nanstd(flat_dataset.all_data, axis=0)/np.sqrt(len(flat_dataset)) + #determine the standard error of the mean: stddev/sqrt(n_frames) + flat_field.err = np.nanstd(flat_dataset.all_data, axis=0)/np.sqrt(len(flat_dataset)) + flat_field.err=flat_field.err.reshape((1,)+flat_field.err.shape) # Get it into the right dimension - return master_flat + + return flat_field def get_relgains(frame, em_gain, non_lin_correction): """ diff --git a/corgidrp/l2a_to_l2b.py b/corgidrp/l2a_to_l2b.py index 96836bbc..119b5202 100644 --- a/corgidrp/l2a_to_l2b.py +++ b/corgidrp/l2a_to_l2b.py @@ -58,37 +58,38 @@ def dark_subtraction(input_dataset, dark_frame): return darksub_dataset -def flat_division(input_dataset, master_flat): +def flat_division(input_dataset, flat_field): """ Divide the dataset by the master flat field. Args: input_dataset (corgidrp.data.Dataset): a dataset of Images (L2a-level) - master_flat (corgidrp.data.Flat): a master flat field to divide by + flat_field (corgidrp.data.FlatField): a master flat field to divide by Returns: corgidrp.data.Dataset: a version of the input dataset with the flat field divided out """ # copy of the dataset - flatcal_dataset = input_dataset.copy() + flatdiv_dataset = input_dataset.copy() #Divide by the master flat - flatcal_cube = flatcal_dataset.all_data/master_flat.data + flatdiv_cube = flatdiv_dataset.all_data / flat_field.data # propagate the error of the master flat frame # Check this error prop - if hasattr(master_flat, "err"): - flatcal_dataset.add_error_term(master_flat.err, "masterflat_error") + if hasattr(flat_field, "err"): + flatdiv_dataset.rescale_error(flat_field.err[0], "FlatField error") + flatdiv_dataset.add_error_term(flatdiv_dataset.all_data*flat_field.err[0], "FlatField error") else: - raise Warning("no error attribute in the master flat") + raise Warning("no error attribute in the FlatField") - history_msg = "Flat calibration done using master_flat".format(master_flat.filename) + history_msg = "Flat calibration done using Flat field {0}".format(flat_field.filename) # update the output dataset with this new flat calibrated data and update the history - flatcal_dataset.update_after_processing_step(history_msg, new_all_data=flatcal_cube) + flatdiv_dataset.update_after_processing_step(history_msg,new_all_data=flatdiv_cube) - return flatcal_dataset + return flatdiv_dataset def frame_select(input_dataset): """ @@ -102,23 +103,35 @@ def frame_select(input_dataset): Returns: corgidrp.data.Dataset: a version of the input dataset with only the frames we want to use """ - return None + return input_dataset.copy() -def convert_to_electrons(input_dataset): +def convert_to_electrons(input_dataset, k_gain): """ Convert the data from ADU to electrons. TODO: Establish the interaction with the CalDB for obtaining gain calibration - TODO: Make sure to update the headers to reflect the change in units Args: input_dataset (corgidrp.data.Dataset): a dataset of Images (L2a-level) + k_gain (corgidrp.data.KGain): KGain calibration file Returns: corgidrp.data.Dataset: a version of the input dataset with the data in electrons """ + # you should make a copy the dataset to start + kgain_dataset = input_dataset.copy() + kgain_cube = kgain_dataset.all_data + kgain_error = kgain_dataset.all_err + + kgain = k_gain.value #extract from caldb + kgain_cube *= kgain + kgain_error *= kgain + + history_msg = "data converted to detected EM electrons by kgain {0}".format(str(kgain)) - return None + # update the output dataset with this converted data and update the history + kgain_dataset.update_after_processing_step(history_msg, new_all_data=kgain_cube, new_all_err=kgain_error, header_entries = {"BUNIT":"detected EM electrons", "KGAIN":kgain}) + return kgain_dataset def em_gain_division(input_dataset): """ @@ -156,8 +169,6 @@ def em_gain_division(input_dataset): emgain_dataset.update_after_processing_step(history_msg, new_all_data=emgain_cube, new_all_err=emgain_error, header_entries = {"BUNIT":"detected electrons"}) return emgain_dataset - - def cti_correction(input_dataset): """ @@ -172,9 +183,7 @@ def cti_correction(input_dataset): corgidrp.data.Dataset: a version of the input dataset with the CTI correction applied """ - return None - - + return input_dataset.copy() def correct_bad_pixels(input_dataset): @@ -199,5 +208,5 @@ def correct_bad_pixels(input_dataset): corgidrp.data.Dataset: a version of the input dataset with bad pixels corrected """ - return None + return input_dataset.copy() diff --git a/corgidrp/mocks.py b/corgidrp/mocks.py index 16b3848a..58ecd720 100644 --- a/corgidrp/mocks.py +++ b/corgidrp/mocks.py @@ -35,29 +35,28 @@ def create_dark_calib_files(filedir=None, numfiles=10): dataset = data.Dataset(frames) return dataset -def create_flat_calib_files(filedir=None, numfiles=10): +def create_simflat_dataset(filedir=None, numfiles=10): """ - Create simulated data to create a master flat. - Assume these have already undergone L1 processing and are L2a level products - + Create simulated data to check the flat division + Args: filedir (str): (Optional) Full path to directory to save to. numfiles (int): Number of files in dataset. Defaults to 10. Returns: corgidrp.data.Dataset: - The simulated dataset + The simulated dataset """ # Make filedir if it does not exist if (filedir is not None) and (not os.path.exists(filedir)): os.mkdir(filedir) - filepattern = "simcal_flat_{0:04d}.fits" + filepattern = "sim_flat_{0:04d}.fits" frames = [] for i in range(numfiles): prihdr, exthdr = create_default_headers() # generate images in normal distribution with mean 1 and std 0.01 - np.random.seed(456+i); sim_data = np.random.normal(loc=1.0, scale=0.01, size=(1024, 1024)) + np.random.seed(456+i); sim_data = np.random.poisson(lam=150., size=(1024, 1024)).astype(np.float64) frame = data.Image(sim_data, pri_hdr=prihdr, ext_hdr=exthdr) if filedir is not None: frame.save(filedir=filedir, filename=filepattern.format(i)) @@ -65,6 +64,36 @@ def create_flat_calib_files(filedir=None, numfiles=10): dataset = data.Dataset(frames) return dataset +def create_flatfield_dummy(filedir=None, numfiles=2): + + """ + Turn this flat field dataset of image frames that were taken for performing the flat calibration and + to make one master flat image + + Args: + filedir (str): (Optional) Full path to directory to save to. + numfiles (int): Number of files in dataset. Defaults to 1 to create the dummy flat can be changed to any number + + Returns: + corgidrp.data.Dataset: + a set of flat field images + """ + ## Make filedir if it does not exist + if (filedir is not None) and (not os.path.exists(filedir)): + os.mkdir(filedir) + + filepattern= "flat_field_{0:01d}.fits" + frames=[] + for i in range(numfiles): + prihdr, exthdr = create_default_headers() + np.random.seed(456+i); sim_data = np.random.normal(loc=1.0, scale=0.01, size=(1024, 1024)) + frame = data.Image(sim_data, pri_hdr=prihdr, ext_hdr=exthdr) + if filedir is not None: + frame.save(filedir=filedir, filename=filepattern.format(i)) + frames.append(frame) + flatfield = data.Dataset(frames) + return flatfield + def create_nonlinear_dataset(filedir=None, numfiles=2,em_gain=2000): """ Create simulated data to non-linear data to test non-linearity correction. diff --git a/tests/test_flat_div.py b/tests/test_flat_div.py index b3538109..a2d8dc1a 100644 --- a/tests/test_flat_div.py +++ b/tests/test_flat_div.py @@ -2,62 +2,83 @@ import glob import pytest import numpy as np +import corgidrp import corgidrp.data as data import corgidrp.mocks as mocks import corgidrp.detector as detector import corgidrp.l2a_to_l2b as l2a_to_l2b -def test_flat_div(): - +old_err_tracking = corgidrp.track_individual_errors + +def test_flat_div(): """ Generate mock input data and pass into flat division function """ - ###### create simulated data + corgidrp.track_individual_errors = True # this test uses individual error components + + ###### create simulated data # check that simulated data folder exists, and create if not - datadir = os.path.join(os.path.dirname(__file__), "simflatdata") + datadir = os.path.join(os.path.dirname(__file__), "simdata") if not os.path.exists(datadir): - os.mkdir(datadir) - - mocks.create_flat_calib_files(filedir=datadir) + os.mkdir(datadir) + mocks.create_simflat_dataset(filedir=datadir) - flat_filenames = glob.glob(os.path.join(datadir, "simcal_flat*.fits")) - + # simulated images to be checked in flat division + simdata_filenames=glob.glob(os.path.join(datadir, "sim_flat*.fits")) + simflat_dataset=data.Dataset(simdata_filenames) + + # creat one dummy flat field perform flat division + mocks.create_flatfield_dummy(filedir=datadir) + #test data architecture + flat_filenames = glob.glob(os.path.join(datadir, "flat_field*.fits")) flat_dataset = data.Dataset(flat_filenames) - - assert len(flat_dataset) == 10 - - - - ###### create master flat - flat_frame = detector.create_master_flat(flat_dataset) - + #check that data is consistently modified + flat_dataset.all_data[0,0,0] = 1 + assert flat_dataset[0].data[0,0] == 1 + flat_dataset[0].data[0,0] = 1 + assert flat_dataset.all_data[0,0,0] == 1 + ###### create flatfield + flat_frame = detector.create_flatfield(flat_dataset) + # check the level of counts in flatfield is approximately correct + assert np.mean(flat_frame.data) == pytest.approx(1, abs=1e-2) # check that the error is determined correctly - assert np.array_equal(np.std(flat_dataset.all_data, axis = 0)/np.sqrt(len(flat_dataset)), flat_frame.err) - - # save flat - calibdir = os.path.join(os.path.dirname('test'), "testcalib") + assert np.array_equal(np.std(flat_dataset.all_data, axis = 0)/np.sqrt(len(flat_dataset)), flat_frame.err[0]) + # save flatfield + calibdir = os.path.join(os.path.dirname(__file__), "testcalib") flat_filename = "sim_flat_calib.fits" if not os.path.exists(calibdir): os.mkdir(calibdir) - flat_frame.save(filedir=calibdir, filename=flat_filename) + flat_frame.save(filedir=calibdir, filename=flat_filename) ###### perform flat division - # load in the masterflat + # load in the flatfield flat_filepath = os.path.join(calibdir, flat_filename) - new_masterflat = data.Masterflat(flat_filepath) - # divide sim_data from masterflat - flat_dataset = l2a_to_l2b.flat_division(flat_dataset, new_masterflat) - #assert(flat_filename in str(flat_dataset[0].ext_hdr["HISTORY"])) - - # check the level of the dataset is now approximately 0 - assert np.mean(flat_dataset.all_data) == pytest.approx(1, abs=1e-2) + flatfield = data.FlatField(flat_filepath) + # divide the simulated dataset with the dummy flatfield + flatdivided_dataset = l2a_to_l2b.flat_division(simflat_dataset, flatfield) + + # perform checks after the flat divison + assert(flat_filename in str(flatdivided_dataset[0].ext_hdr["HISTORY"])) + # check the level of the dataset is now approximately 100 + assert np.mean(flatdivided_dataset.all_data) == pytest.approx(150, abs=1e-2) # check the propagated errors - assert flat_dataset[0].err_hdr["Layer_2"] == "masterflat_error" - assert(np.mean(flat_dataset.all_err) == pytest.approx(np.mean(flat_frame.err), abs = 1e-2)) - print("mean of all data:", np.mean(flat_dataset.all_data)) - print("mean of all errors:", np.mean(flat_dataset.all_err)) - print(flat_dataset[0].ext_hdr) + assert flatdivided_dataset[0].err_hdr["Layer_2"] == "FlatField error" + print("mean of all simulated data",np.mean(simflat_dataset.all_data)) + print("mean of all simulated data error",np.mean(simflat_dataset.all_err) ) + print("mean of all flat divided data:", np.mean(flatdivided_dataset.all_data)) + print("mean of all flat divided data errors:", np.mean(flatdivided_dataset.all_err)) + print("mean of flatfield:", np.mean(flatfield.data)) + print("mean of flatfield err:", np.mean(flatfield.err)) + + err_flatdiv=np.mean(flatdivided_dataset.all_err) + err_estimated=np.sqrt(((np.mean(flatfield.data))**2)*(np.mean(simflat_dataset.all_err))**2+((np.mean(simflat_dataset.all_data))**2)*(np.mean(flatfield.err))**2) + print("mean of all flat divided data errors:",err_flatdiv) + print("Error estimated:",err_estimated) + assert(err_flatdiv == pytest.approx(err_estimated, abs = 1e-0)) + + print(flatdivided_dataset[0].ext_hdr) + corgidrp.track_individual_errors = old_err_tracking if __name__ == "__main__": From 0a13f1a578484f3322fcc9fe9b56f715ab5806ab Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Tue, 11 Jun 2024 11:01:44 -0700 Subject: [PATCH 10/14] fixed errors in build --- corgidrp/data.py | 1 + 1 file changed, 1 insertion(+) diff --git a/corgidrp/data.py b/corgidrp/data.py index 181aa0d7..91a04dc1 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -457,6 +457,7 @@ def add_error_term(self, input_error, err_name): #first layer is always the updated combined error self.err[0,:,:] = np.sqrt(self.err[0,:,:]**2 + input_error**2) self.err_hdr["Layer_1"] = "combined_error" + layer = str(self.err.shape[0]) self.err_hdr["Layer_" + layer] = err_name def rescale_error(self, input_error, err_name): From 02de5be475c16e15f0b274c382b2fcec620cb078 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Tue, 11 Jun 2024 16:06:23 -0700 Subject: [PATCH 11/14] fixed build errors --- corgidrp/data.py | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 91a04dc1..52df2534 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -159,7 +159,6 @@ def add_error_term(self, input_error, err_name): for i, frame in enumerate(self.frames): frame.err = self.all_err[i] - def rescale_error(self, input_error, err_name): """ Calls Image.rescale_errors() for each frame. @@ -183,9 +182,8 @@ def rescale_error(self, input_error, err_name): # Preserve pointer links between Dataset.all_err and Image.err self.all_err = np.array([frame.err for frame in self.frames]) for i, frame in enumerate(self.frames): - frame.err = self.all_err[i] - - + frame.err = self.all_err[i] + class Image(): """ Base class for 2-D image data. Data can be created by passing in the data/header explicitly, or @@ -457,8 +455,16 @@ def add_error_term(self, input_error, err_name): #first layer is always the updated combined error self.err[0,:,:] = np.sqrt(self.err[0,:,:]**2 + input_error**2) self.err_hdr["Layer_1"] = "combined_error" - layer = str(self.err.shape[0]) - self.err_hdr["Layer_" + layer] = err_name + + if corgidrp.track_individual_errors: + #append new error as layer on 3D cube + self.err=np.append(self.err, [input_error], axis=0) + + layer = str(self.err.shape[0]) + self.err_hdr["Layer_" + layer] = err_name + + # record history since 2-D error map doesn't track individual terms + self.err_hdr['HISTORY'] = "Added error term: {0}".format(err_name) def rescale_error(self, input_error, err_name): """ @@ -500,6 +506,7 @@ def rescale_error(self, input_error, err_name): # record history since 2-D error map doesn't track individual terms self.err_hdr['HISTORY'] = "Added error term: {0}".format(err_name) + class Dark(Image): """ @@ -541,7 +548,6 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'Dark': raise ValueError("File that was loaded was not a Dark file.") - class FlatField(Image): """ Master flat generated from raster scan of uranus or Neptune. @@ -579,7 +585,8 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N # since if only a filepath was passed in, any file could have been read in if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'FlatField': raise ValueError("File that was loaded was not a FlatField file.") - + + class NonLinearityCalibration(Image): """ Class for non-linearity calibration files. Although it's not stricly an image that you might look at, it is a 2D array of data @@ -656,7 +663,8 @@ def __init__(self, data_or_filepath, pri_hdr=None, ext_hdr=None, input_dataset=N # since if only a filepath was passed in, any file could have been read in if 'DATATYPE' not in self.ext_hdr or self.ext_hdr['DATATYPE'] != 'NonLinearityCalibration': raise ValueError("File that was loaded was not a NonLinearityCalibration file.") - + + class KGain(Image): """ Class for KGain calibration file. Until further insights it is just one float value. @@ -811,8 +819,7 @@ def copy(self, copy_data = True): "NonLinearityCalibration" : NonLinearityCalibration, "KGain" : KGain, "BadPixelMap" : BadPixelMap, - "FlatField" :FlatField} - + "FlatField" : FlatField} def autoload(filepath): """ @@ -846,4 +853,4 @@ def autoload(filepath): # use the class constructor to load in the data frame = data_class(filepath) - return frame + return frame \ No newline at end of file From 78ae013f998b515998c65c0520bf41af64cb8266 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Sat, 29 Jun 2024 21:55:33 -0700 Subject: [PATCH 12/14] fixed rescale error function- flat calibration --- corgidrp/data.py | 15 +++------------ corgidrp/l2a_to_l2b.py | 6 +++--- tests/test_flat_div.py | 2 +- 3 files changed, 7 insertions(+), 16 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 52df2534..46e914b9 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -483,7 +483,7 @@ def rescale_error(self, input_error, err_name): raise ValueError("we expect a 2-dimensional error layer with dimensions {0}".format(self.data.shape)) #first layer is always the updated combined error - self.err = np.sqrt(self.err**2 * input_error**2) + self.err = self.err*input_error self.err_hdr["Layer_1"] = "combined_error" if corgidrp.track_individual_errors: @@ -491,21 +491,12 @@ def rescale_error(self, input_error, err_name): self.err=np.append(self.err, [input_error], axis=0) layer = str(self.err.shape[0]) - self.err_hdr["Layer_1"] = "combined_error" + #self.err_hdr["Layer_1"] = "combined_error" self.err_hdr["Layer_" + layer] = err_name # record history since 2-D error map doesn't track individual terms - self.err_hdr['HISTORY'] = "rescaled error term: {0}".format(err_name) + self.err_hdr['HISTORY'] = "Errors rescaled by: {0}".format(err_name) - if corgidrp.track_individual_errors: - #append new error as layer on 3D cube - self.err=np.append(self.err, [input_error], axis=0) - - layer = str(self.err.shape[0]) - self.err_hdr["Layer_" + layer] = err_name - - # record history since 2-D error map doesn't track individual terms - self.err_hdr['HISTORY'] = "Added error term: {0}".format(err_name) class Dark(Image): diff --git a/corgidrp/l2a_to_l2b.py b/corgidrp/l2a_to_l2b.py index 2915ac19..e0b8604d 100644 --- a/corgidrp/l2a_to_l2b.py +++ b/corgidrp/l2a_to_l2b.py @@ -77,10 +77,10 @@ def flat_division(input_dataset, flat_field): #Divide by the master flat flatdiv_cube = flatdiv_dataset.all_data / flat_field.data - # propagate the error of the master flat frame # Check this error prop + # propagate the error of the master flat frame if hasattr(flat_field, "err"): - flatdiv_dataset.rescale_error(flat_field.err[0], "FlatField error") - flatdiv_dataset.add_error_term(flatdiv_dataset.all_data*flat_field.err[0], "FlatField error") + flatdiv_dataset.rescale_error(1/flat_field.data, "FlatField") + flatdiv_dataset.add_error_term(flatdiv_dataset.all_data*flat_field.err[0]/(flat_field.data**2), "FlatField_error") else: raise Warning("no error attribute in the FlatField") diff --git a/tests/test_flat_div.py b/tests/test_flat_div.py index a2d8dc1a..618c9149 100644 --- a/tests/test_flat_div.py +++ b/tests/test_flat_div.py @@ -63,7 +63,7 @@ def test_flat_div(): # check the level of the dataset is now approximately 100 assert np.mean(flatdivided_dataset.all_data) == pytest.approx(150, abs=1e-2) # check the propagated errors - assert flatdivided_dataset[0].err_hdr["Layer_2"] == "FlatField error" + #assert flatdivided_dataset[0].err_hdr["Layer_2"] == "FlatField_error" print("mean of all simulated data",np.mean(simflat_dataset.all_data)) print("mean of all simulated data error",np.mean(simflat_dataset.all_err) ) print("mean of all flat divided data:", np.mean(flatdivided_dataset.all_data)) From d9f1bddccee3409564f7018d8aa9d3bb676b5506 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Sun, 30 Jun 2024 19:25:22 -0700 Subject: [PATCH 13/14] fixed rescale errors --- corgidrp/data.py | 10 +--------- corgidrp/detector.py | 2 +- tests/test_flat_div.py | 4 ++-- 3 files changed, 4 insertions(+), 12 deletions(-) diff --git a/corgidrp/data.py b/corgidrp/data.py index 46e914b9..90bf7ad2 100644 --- a/corgidrp/data.py +++ b/corgidrp/data.py @@ -485,15 +485,7 @@ def rescale_error(self, input_error, err_name): #first layer is always the updated combined error self.err = self.err*input_error self.err_hdr["Layer_1"] = "combined_error" - - if corgidrp.track_individual_errors: - #append new error as layer on 3D cube - self.err=np.append(self.err, [input_error], axis=0) - - layer = str(self.err.shape[0]) - #self.err_hdr["Layer_1"] = "combined_error" - self.err_hdr["Layer_" + layer] = err_name - + # record history since 2-D error map doesn't track individual terms self.err_hdr['HISTORY'] = "Errors rescaled by: {0}".format(err_name) diff --git a/corgidrp/detector.py b/corgidrp/detector.py index 2b50b706..7b05db95 100644 --- a/corgidrp/detector.py +++ b/corgidrp/detector.py @@ -38,7 +38,7 @@ def create_flatfield(flat_dataset): flat_dataset (corgidrp.data.Dataset): a dataset of Image frames (L2a-level) Returns: - data.masterflat: a master flat for flat calibration + data.FlatField: a master flat for flat calibration """ diff --git a/tests/test_flat_div.py b/tests/test_flat_div.py index 618c9149..904362f6 100644 --- a/tests/test_flat_div.py +++ b/tests/test_flat_div.py @@ -63,7 +63,7 @@ def test_flat_div(): # check the level of the dataset is now approximately 100 assert np.mean(flatdivided_dataset.all_data) == pytest.approx(150, abs=1e-2) # check the propagated errors - #assert flatdivided_dataset[0].err_hdr["Layer_2"] == "FlatField_error" + assert flatdivided_dataset[0].err_hdr["Layer_2"] == "FlatField_error" print("mean of all simulated data",np.mean(simflat_dataset.all_data)) print("mean of all simulated data error",np.mean(simflat_dataset.all_err) ) print("mean of all flat divided data:", np.mean(flatdivided_dataset.all_data)) @@ -75,7 +75,7 @@ def test_flat_div(): err_estimated=np.sqrt(((np.mean(flatfield.data))**2)*(np.mean(simflat_dataset.all_err))**2+((np.mean(simflat_dataset.all_data))**2)*(np.mean(flatfield.err))**2) print("mean of all flat divided data errors:",err_flatdiv) print("Error estimated:",err_estimated) - assert(err_flatdiv == pytest.approx(err_estimated, abs = 1e-0)) + assert(err_flatdiv == pytest.approx(err_estimated, abs = 1e-2)) print(flatdivided_dataset[0].ext_hdr) corgidrp.track_individual_errors = old_err_tracking From f04d5914277f2e858540ab7c583ef6092c1a1dc3 Mon Sep 17 00:00:00 2001 From: Ramya Anche <92347523+ramya-anche@users.noreply.github.com> Date: Mon, 1 Jul 2024 10:29:16 -0700 Subject: [PATCH 14/14] fixed return datatype --- corgidrp/detector.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/corgidrp/detector.py b/corgidrp/detector.py index 7b05db95..17dc5946 100644 --- a/corgidrp/detector.py +++ b/corgidrp/detector.py @@ -38,7 +38,7 @@ def create_flatfield(flat_dataset): flat_dataset (corgidrp.data.Dataset): a dataset of Image frames (L2a-level) Returns: - data.FlatField: a master flat for flat calibration + flat_field (corgidrp.data.FlatField): a master flat for flat calibration """