def run(self, nima=0, **kwargs): """Run the offset and comparison """ if nima not in range(self.nimages): upipe.print_error( "nima not within the range allowed by self.nimages ({0})". format(self.nimages)) return # Overwrite the plot option if given self.plot = kwargs.pop("plot", self.plot) if "extra_pixel" in kwargs: extra_pixel = kwargs.pop("extra_pixel", [0., 0.]) extra_arcsec = pixel_to_arcsec(self.list_muse_hdu[nima], extra_pixel) else: extra_arcsec = kwargs.pop("extra_arcsec", [0., 0.]) # Add the offset from user self.shift_arcsecond(extra_arcsec, nima) # Compare contours if plot is set to True if self.plot: self.compare(self.list_offmuse_hdu[nima], self.list_proj_refhdu[nima], nima=nima, **kwargs)
def chunk_stats(list_data, chunk_size=15): """Cut the datasets in chunks and take the median Return the set of medians """ ndatasets = len(list_data) nchunk_x = np.int(list_data[0].shape[0] // chunk_size - 1) nchunk_y = np.int(list_data[0].shape[1] // chunk_size - 1) # Check that all datasets have the same size med_data = np.zeros((ndatasets, nchunk_x * nchunk_y), dtype=np.float32) std_data = np.zeros_like(med_data) if not all([d.size for d in list_data]): upipe.print_error( "Datasets are not of the same size in median_compare") else: for i in range(0, nchunk_x): for j in range(0, nchunk_y): for k in range(ndatasets): # Taking the median med_data[k, i * nchunk_y + j] = np.median( list_data[k][i * chunk_size:(i + 1) * chunk_size, j * chunk_size:(j + 1) * chunk_size]) std_data[k, i * nchunk_y + j] = mad_std( list_data[k][i * chunk_size:(i + 1) * chunk_size, j * chunk_size:(j + 1) * chunk_size]) return med_data, std_data
def _get_table_expo(self, expotype, stage="master"): try: return getattr(self._dic_tables[stage], self._get_attr_expo(expotype)) except AttributeError: upipe.print_error( "No attributed table with expotype {0} and stage {1}".format( expotype, stage)) return Table()
def save_image(self, newfits_name=None, nima=0): """Save the newly determined hdu """ if hasattr(self, "list_offmuse_hdu"): if newfits_name is None: newfits_name = self.list_name_museimages[nima].replace( ".fits", "_shift.fits") self.list_offmuse_hdu[nima].writeto(newfits_name, overwrite=True) else: upipe.print_error("There are not yet any new hdu to save")
def open_offset_table(self, name_table=None): """Read offset table from fits file """ if name_table is None: if not hasattr(self, name_table): upipe.print_error("No FITS table name provided, Aborting Open") return None, Table() if not os.path.isfile(name_table): upipe.print_warning("FITS Table does not exist yet" "({0})".format(name_table)) return False, Table() return True, Table.read(name_table)
def __init__(self, galaxyname=None, list_pointings=[1]) : if galaxyname not in MUSEPIPE_sample.keys() : upipe.print_error("ERROR: no Galaxy named {gal} in the defined sample".format(gal=galaxyname)) return # Galaxy name upipe.print_info("Initialising Target {name}".format(name=galaxyname)) self.targetname = galaxyname # Info of the pointings and extracting the observing run for each pointing self.info_pointings = MUSEPIPE_sample[galaxyname] if any([_ not in self.info_pointings.keys() for _ in list_pointings]) : upipe.print_error("ERROR: no pointing {0} for the Galaxy".format(list_pointings)) return self.list_pointings = list_pointings self.observing_run = [self.info_pointing[_] for _ in self.list_pointings]
def save_fits_offset_table(self, name_output_table=None, overwrite=False, suffix=""): """Save the Offsets into a fits Table """ if name_out_table is None: name_out_table = self.name_input_table self.suffix = suffix name_output_table = name_output_table.replace( ".fits", "{0}.fits".format(self.suffix)) exist_table, fits_table = self.open_offset_table(self.name_out_table) if exist_table is None: upipe.print_error("Save is aborted") return # Check if RA_OFFSET is there if 'RA_OFFSET' in fits_table.columns: # if yes, then check if the ORIG column is there if 'RA_OFFSET_ORIG' not in fits_table.columns: fits_table['RA_OFFSET_ORIG'] = fits_table['RA_OFFSET'] fits_table['DEC_OFFSET_ORIG'] = fits_table['DEC_OFFSET'] # if not, just continue # as it means the ORIG columns were already done # Saving the final values fits_table['RA_OFFSET'] = self.total_off_arcsec[:, 0] / 3600. fits_table['DEC_OFFSET'] = self.total_off_arcsec[:, 1] / 3600. fits_table['RA_CROSS_OFFSET'] = self.cross_off_arcsec[:, 0] / 3600. fits_table['DEC_CROSS_OFFSET'] = self.cross_off_arcsec[:, 1] / 3600. # Writing it up if exist_table and not overwrite: upipe.print_warning( "Table already exists, but overwrite is set to False") upipe.print_warning( "If you wish to overwrite the table {0}, " "please set overwrite to True".format(name_output_table)) return fits_table.write(self.name_output_table, overwrite=overwrite) self.name_output_table = name_output_table
def print_offset_fromfits(self, name_table=None): """Print out the offset """ exist_table, fits_table = self.open_offset_table(name_table) if exist_table is None: return if ('RA_OFFSET' not in fits_table.columns) or ('DEC_OFFSET' not in fits_table.columns): upipe.print_error( "Table does not contain 'RA/DEC_OFFSET' columns, Aborting") return upipe.print_info("Offset recorded in OFFSET_LIST Table") upipe.print_info("Total in ARCSEC") for i in self.nimages: upipe.print_info("Image {0}: " "{1:8.4f} {1:8.4f}".format( fits_table['RA_OFFSET'] * 3600, fits_table['DEC_OFFSET'] * 3600.))
def run_pipeline(self, list_pointings=[1], fakemode=False, suffix_logfile="logfile", suffix_rcfile="rcfile", suffix_calfile="calfile"): """Run the pipeline for all pointings in the list """ if any([_ not in self.info_pointings.keys() for _ in self.list_pointings]) : upipe.print_error("ERROR: some pointing are not in " "the available list ({0})".format(self.list_pointings)) return # Setting up the suffixes for the files self.suffix_logfile = suffix_logfile self.suffix_calfile = suffix_calfile self.suffix_rcfile = suffix_rcfile # Loop on the pointings self.pipelines = [] upipe.print_info("---- Starting the Data Reduction ----") self.history = [] for pointing in list_pointings: # Setting up the names of the output files logfile = self._get_logfile_name(self.suffix_logfile, pointing) calfile = self._get_calfile_name(self.suffix_calfile, pointing) rcfile = self._get_rcfile_name(self.suffix_rcfile, pointing) python_command = ("mypipe = musepipe.MusePipe(galaxyname={0}, " "pointing={1}, rc_filename={2}, cal_filename={3}, " "outlog=None, logfile={4}, fakemode={5}, " "nocache=False)".format(galaxyname, pointing, rcfile, calfile, logfile, fakemode)) upipe.print_info("====== START - POINTING {0:2d} ======".format(pointing)) upipe.print_info(python_command) upipe.print_info("====== END - POINTING {0:2d} ======".format(pointing)) self.history.append(python_command) mypipe = MusePipe(galaxyname=galaxyname, pointing=pointing, rc_filename=rcfile, cal_filename=calfile, outlog=None, logfile=logfile, fakemode=fakemode, nocache=False) self.pipelines.append(mypipe) mypipe.run_all_recipes()