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
boot = CleanBootstrap([model], uvdata)
os.chdir(data_dir)
boot.run(100, nonparametric=False, use_v=False)
booted_uv_fits = glob.glob(os.path.join(data_dir, 'bootstrapped_data*.fits'))
for i, boot_uv in enumerate(sorted(booted_uv_fits)):
clean_difmap(boot_uv,
'booted_cc_{}.fits'.format(i),
'I', (512, 0.1),
path=data_dir,
path_to_script=path_to_script,
outpath=data_dir)
booted_im_fits = glob.glob(os.path.join(data_dir, 'booted_cc*.fits'))
images = Images()
images.add_from_fits(booted_im_fits)
error_image = images.create_error_image()
orig_image = create_clean_image_from_fits_file(os.path.join(data_dir, im_fits))
rms = rms_image_shifted(os.path.join(data_dir, uv_fits),
image_fits=os.path.join(data_dir, im_fits),
path_to_script=path_to_script)
blc, trc = find_bbox(orig_image.image, level=1.5 * rms)
image_mask = orig_image.image < 2 * rms
label_size = 14
matplotlib.rcParams['xtick.labelsize'] = label_size
matplotlib.rcParams['ytick.labelsize'] = label_size
matplotlib.rcParams['axes.titlesize'] = label_size
matplotlib.rcParams['axes.labelsize'] = label_size
matplotlib.rcParams['font.size'] = label_size
matplotlib.rcParams['legend.fontsize'] = label_size
# 3c273
# 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]
ppol_images_dict.update({band: ppol_image})
mask = ppol_image.image < ppol_error_image.image
