def create_boot_pang_errors(self, cred_mass=0.68, n_sigma=None): """ Create dictionary with images of PANG errors calculated from bootstrap PANG maps. :param cred_mass: (optional) Credibility mass. (default: ``0.68``) :param n_sigma: (optional) Sigma clipping for mask. If ``None`` then use instance's value. (default: ``None``) :return: Dictionary with keys - frequencies & values - instances of ``Image`` class with error maps. """ print( "Calculating maps of PANG errors for each band using bootstrapped" " PANG maps...") result = dict() if n_sigma is not None: self.set_common_mask(n_sigma) # Fetch common size `I` map on highest frequency for plotting PANG error # maps i_image = self.cc_cs_image_dict[self.freqs[-1]]['I'] rms = rms_image(i_image) blc, trc = find_bbox(i_image.image, 2. * rms, delta=int(i_image._beam.beam[0])) for i, freq in enumerate(self.freqs): images = self.boot_images.create_pang_images(freq=freq, mask=self._cs_mask) pang_images = Images() pang_images.add_images(images) error_image = pang_images.create_error_image(cred_mass=cred_mass) # As this errors are used for linear fit judgement only - add EVPA # absolute calibration error in quadrature evpa_error = np.deg2rad(self.sigma_evpa[i]) * np.ones( error_image.image.shape) error_image.image = np.sqrt((error_image.image)**2. + evpa_error**2.) result[freq] = error_image fig = iplot(i_image.image, error_image.image, x=i_image.x, y=i_image.y, min_abs_level=3. * rms, colors_mask=self._cs_mask, color_clim=[0, 1], blc=blc, trc=trc, beam=self.common_beam, colorbar_label='sigma EVPA, [rad]', slice_points=None, show_beam=True, show=False, cmap='hsv') self.figures['EVPA_sigma_boot_{}'.format(freq)] = fig self.evpa_sigma_boot_dict = result return result
dpi=200) # For each frequency create mask based on PPOL distribution ppol_error_images_dict = dict() pang_error_images_dict = dict() ppol_images_dict = dict() pang_images_dict = dict() ppol_masks_dict = dict() for band in bands: images_ = create_images_from_boot_images(source, epoch, [band], stokes, base_path=base_path) ppol_images = Images() pang_images = Images() ppol_images.add_images(images_.create_pol_images()) pang_images.add_images(images_.create_pang_images()) ppol_error_image = ppol_images.create_error_image(cred_mass=0.95) pang_error_image = pang_images.create_error_image(cred_mass=0.68) ppol_error_images_dict.update({band: ppol_error_image}) pang_error_images_dict.update({band: pang_error_image}) images_ = Images() for stoke in stokes: map_path = im_fits_path(source, band, epoch, stoke, base_path=base_path) images_.add_from_fits( wildcard=os.path.join(map_path, 'cc_orig.fits')) ppol_image = images_.create_pol_images()[0]
def analyze_source(uv_fits_paths, n_boot, imsizes=None, common_imsize=None, common_beam=None, find_shifts=False, outdir=None, path_to_script=None, clear_difmap_logs=True, rotm_slices=None): """ Function that uses multifrequency self-calibration data for in-depth analysis. :param uv_fits_paths: Iterable of paths to self-calibrated uv-data FITS-files. :param n_boot: Number of bootstrap replications to use in analysis. :param imsizes: (optional) Iterable of image parameters (imsize, pixsize) that should be used for CLEANing of uv-data if no CLEAN-images are supplied. Should be sorted in increasing frequency order. If ``None`` then specify parameters by CLEAN images. (default: ``None``) :param common_imsize: (optional) Image parameters that will be used in making common size images for multifrequency analysis. If ``None`` then use physical image size of lowest frequency and pixel size of highest frequency. (default: ``None``) :param outdir: (optional) Output directory. This directory will be used for saving picture, data, etc. If ``None`` then use CWD. (default: ``None``) :param path_to_script: (optional) Path ot difmap CLEAN script. If ``None`` then use CWD. (default: ``None``) :notes: Workflow: 1) Чистка с родным разрешением всех N диапазонов и получение родных моделей I, Q, U. 2) Выбор общей ДН из N возможных 3) (Опционально) Выбор uv-tapering 4) Чистка uv-данных для всех диапазонов с (опционально применяемым uv-tapering) общей ДН 5) Оценка сдвига ядра 6) Создание B наборов из N многочастотных симулированных данных используя родные модели 7) (Опционально) Чистка B наборов из N многочастотных симданных с родным разрешением для получения карт ошибок I для каждой из N частот 8) Чистка B наборов из N многочастотных симданных для всех диапазонов с (опционально применяемым uv-tapering) общей ДН 9) Оценка ошибки определения сдвига ядра 10) Оценка RM и ее ошибки 11) Оценка alpha и ее ошибки """ # Fail early if imsizes is None: raise Exception("Provide imsizes argument!") if common_imsize is not None: print("Using common image size {}".format(common_imsize)) else: raise Exception("Provide common_imsize argument!") # Setting up the output directory if outdir is None: outdir = os.getcwd() print("Using output directory {}".format(outdir)) os.chdir(outdir) # Assume input self-calibrated uv-data FITS files have different frequencies n_freq = len(uv_fits_paths) print("Using {} frequencies".format(n_freq)) # Assuming full multifrequency analysis stokes = ('I', 'Q', 'U') # Container for original self-calibrated uv-data uv_data_dict = dict() # Container for original self-calibrated uv-data FITS-file paths uv_fits_dict = dict() for uv_fits_path in uv_fits_paths: uvdata = UVData(uv_fits_path) # Mark frequencies by total band center [Hz] for consistency with image. uv_data_dict.update({uvdata.band_center: uvdata}) uv_fits_dict.update({uvdata.band_center: uv_fits_path}) # Lowest frequency goes first freqs = sorted(uv_fits_dict.keys()) print("Frequencies are: {}".format(freqs)) # Assert we have original map parameters for all frequencies assert len(imsizes) == n_freq # Container for original CLEAN-images of self-calibrated uv-data cc_image_dict = dict() # Container for paths to FITS-files with original CLEAN-images of # self-calibrated uv-data cc_fits_dict = dict() # Container for original CLEAN-image's beam parameters cc_beam_dict = dict() for freq in freqs: cc_image_dict.update({freq: dict()}) cc_fits_dict.update({freq: dict()}) cc_beam_dict.update({freq: dict()}) # 1. # Clean original uv-data with specified map parameters print("1. Clean original uv-data with specified map parameters...") imsizes_dict = dict() for i, freq in enumerate(freqs): imsizes_dict.update({freq: imsizes[i]}) for freq in freqs: uv_fits_path = uv_fits_dict[freq] uv_dir, uv_fname = os.path.split(uv_fits_path) for stoke in stokes: outfname = '{}_{}_cc.fits'.format(freq, stoke) outpath = os.path.join(outdir, outfname) clean_difmap(uv_fname, outfname, stoke, imsizes_dict[freq], path=uv_dir, path_to_script=path_to_script, outpath=outdir) cc_fits_dict[freq].update({stoke: os.path.join(outdir, outfname)}) image = create_clean_image_from_fits_file(outpath) cc_image_dict[freq].update({stoke: image}) if stoke == 'I': cc_beam_dict.update({freq: image.beam}) # Containers for images and paths to FITS files with common size images cc_cs_image_dict = dict() cc_cs_fits_dict = dict() # 2. # Choose common beam size print("2. Choosing common beam size...") if common_beam is None: common_beam = cc_beam_dict[freqs[0]] print("Using common beam [mas, mas, deg] : {}".format(common_beam)) # 3. # Optionally uv-tapering uv-data print("3. Optionally uv-tapering uv-data...") print("skipping...") # 4. # Clean original uv-data with common map parameters print("4. Clean original uv-data with common map parameters...") for freq in freqs: cc_cs_image_dict.update({freq: dict()}) cc_cs_fits_dict.update({freq: dict()}) uv_fits_path = uv_fits_dict[freq] uv_dir, uv_fname = os.path.split(uv_fits_path) for stoke in stokes: outfname = 'cs_{}_{}_cc.fits'.format(freq, stoke) outpath = os.path.join(outdir, outfname) # clean_difmap(uv_fname_cc, outfname, stoke, common_imsize, # path=uv_dir, path_to_script=path_to_script, # outpath=outdir, show_difmap_output=False) cc_cs_fits_dict[freq].update( {stoke: os.path.join(outdir, outfname)}) image = create_image_from_fits_file(outpath) cc_cs_image_dict[freq].update({stoke: image}) # 5. # Optionally find shifts between original CLEAN-images print("5. Optionally find shifts between original CLEAN-images...") if find_shifts: print("Determining images shift...") shift_dict = dict() freq_1 = freqs[0] image_1 = cc_image_dict[freq_1]['I'] for freq_2 in freqs[1:]: image_2 = cc_image_dict[freq_2]['I'] # Coarse grid of possible shifts shift = find_shift(image_1, image_2, 100, 5, max_mask_r=200, mask_step=5) # More accurate grid of possible shifts print("Using fine grid for accurate estimate") coarse_grid = range(0, 100, 5) idx = coarse_grid.index(shift) if idx > 0: min_shift = coarse_grid[idx - 1] else: min_shift = 0 shift = find_shift(image_1, image_2, coarse_grid[idx + 1], 1, min_shift=min_shift, max_mask_r=200, mask_step=5) shift_dict.update({str(( freq_1, freq_2, )): shift}) # Dumping shifts to json file in target directory with open(os.path.join(outdir, "shifts_original.json"), 'w') as fp: json.dump(shift_dict, fp) else: print("skipping...") # 6. # Bootstrap self-calibrated uv-data with CLEAN-models print("6. Bootstrap self-calibrated uv-data with CLEAN-models...") uv_boot_fits_dict = dict() for freq, uv_fits_path in uv_fits_dict.items(): # cc_fits_paths = [cc_fits_dict[freq][stoke] for stoke in stokes] # bootstrap_uv_fits(uv_fits_path, cc_fits_paths, n_boot, outpath=outdir, # outname=('boot_{}'.format(freq), '_uv.fits')) files = glob.glob(os.path.join(outdir, 'boot_{}*.fits'.format(freq))) uv_boot_fits_dict.update({freq: sorted(files)}) # 7. # Optionally clean bootstrap replications with original restoring beams and # map sizes to get error estimates for original resolution maps of I, PPOL, # FPOL, ... print( "7. Optionally clean bootstrap replications with original restoring" " beams and map sizes...") print("skipping...") # 8. # Optionally clean bootstrap replications with common restoring beams and # map sizes print( "8. Optionally clean bootstrap replications with common restoring" " beams and map sizes...") cc_boot_fits_dict = dict() for freq in freqs: cc_boot_fits_dict.update({freq: dict()}) uv_fits_paths = uv_boot_fits_dict[freq] for stoke in stokes: for i, uv_fits_path in enumerate(uv_fits_paths): uv_dir, uv_fname = os.path.split(uv_fits_path) outfname = 'boot_{}_{}_cc_{}.fits'.format( freq, stoke, str(i + 1).zfill(3)) # clean_difmap(uv_fname_cc, outfname, stoke, common_imsize, # path=uv_dir, path_to_script=path_to_script, # outpath=outdir, show_difmap_output=False) files = sorted( glob.glob( os.path.join(outdir, 'boot_{}_{}_cc_*.fits'.format(freq, stoke)))) cc_boot_fits_dict[freq].update({stoke: files}) # 9. Optionally estimate RM map and it's error print("9. Optionally estimate RM map and it's error...") original_cs_images = Images() for freq in freqs: for stoke in stokes: original_cs_images.add_images(cc_cs_image_dict[freq][stoke]) # Find rough mask for creating bootstrap images of RM, alpha, ... print("Finding rough mask for creating bootstrap images of RM, alpha, ...") cs_mask = pol_mask( {stoke: cc_cs_image_dict[freqs[-1]][stoke] for stoke in stokes}, n_sigma=3.) rotm_image, _ = original_cs_images.create_rotm_image(mask=cs_mask) boot_images = Images() fnames = sorted(glob.glob(os.path.join(data_dir, "boot_*_*_cc_*.fits"))) for freq in freqs: for stoke in stokes: boot_images.add_from_fits(cc_boot_fits_dict[freq][stoke]) boot_rotm_images = boot_images.create_rotm_images(mask=cs_mask) s_rotm_image = boot_rotm_images.create_error_image(cred_mass=0.95) if rotm_slices is not None: fnames = [ 'rotm_slice_spread_{}.png'.format(i + 1) for i in range(len(rotm_slices)) ] for rotm_slice, fname in zip(rotm_slices, fnames): analyze_rotm_slice(rotm_slice, rotm_image, boot_rotm_images, outdir=outdir, outfname=fname) # # Calculate simulataneous confidence bands # # Bootstrap slices # slices = list() # for image in rotm_images_sym.images: # slice_ = image.slice((216, 276), (296, 276)) # slices.append(slice_[~np.isnan(slice_)]) # # Find means # obs_slice = rotm_image_sym.slice((216, 276), (296, 276)) # x = np.arange(216, 296, 1) # x = x[~np.isnan(obs_slice)] # obs_slice = obs_slice[~np.isnan(obs_slice)] # # Find sigmas # slices_ = [arr.reshape((1, len(obs_slice))) for arr in slices] # sigmas = hdi_of_arrays(slices_).squeeze() # means = np.mean(np.vstack(slices), axis=0) # diff = obs_slice - means # # Move bootstrap curves to original simulated centers # slices_ = [slice_ + diff for slice_ in slices] # # Find low and upper confidence band # low, up = create_sim_conf_band(slices_, obs_slice, sigmas, # alpha=conf_band_alpha) # # Plot confidence bands and model values # fig = plt.figure() # ax = fig.add_subplot(1, 1, 1) # ax.plot(x, low[::-1], 'g') # ax.plot(x, up[::-1], 'g') # [ax.plot(x, slice_[::-1], 'r', lw=0.15) for slice_ in slices_] # ax.plot(x, obs_slice[::-1], '.k') # # Plot ROTM model # ax.plot(np.arange(216, 296, 1), # rotm_grad_value * (np.arange(216, 296, 1) - 256.)[::-1] + # rotm_value_0) # fig.savefig(os.path.join(data_dir, 'rotm_slice_spread.png'), # bbox_inches='tight', dpi=200) # plt.close() if clear_difmap_logs: print("Removing difmap log-files...") difmap_logs = glob.glob(os.path.join(outdir, "difmap.log*")) for difmpa_log in difmap_logs: os.unlink(difmpa_log)