def make_polcubes(self):
"""
Function to generate the cubes in Q and U from the polarisation mosaics
"""
# Set the directories for the mosaicking
utils.set_mosdirs(self)
# Get the fits files
Qmoss = sorted(glob.glob(self.polmosaicdir + '/*_[0-9][0-9]_Q.fits'))
Umoss = sorted(glob.glob(self.polmosaicdir + '/*_[0-9][0-9]_U.fits'))
Qmoss_uncorr = sorted(
glob.glob(self.polmosaicdir + '/*_[0-9][0-9]_Q_uncorr.fits'))
Umoss_uncorr = sorted(
glob.glob(self.polmosaicdir + '/*_[0-9][0-9]_U_uncorr.fits'))
# Check if the same number of mosaics is available for Q and U
Qmoss_chk = []
Umoss_chk = []
for qchk in Qmoss:
qnew = qchk.replace('_Q', '')
Qmoss_chk.append(qnew)
for uchk in Umoss:
unew = uchk.replace('_U', '')
Umoss_chk.append(unew)
if Qmoss_chk == Umoss_chk:
pass
else:
print(
'Different number of Q and U mosaics. Cannot generate cubes!')
sys.exit()
# Find the smallest mosaic image
allim = sorted(Qmoss + Umoss)
allim_uncorr = sorted(Qmoss_uncorr + Umoss_uncorr)
naxis1 = []
naxis2 = []
for mos in allim:
with pyfits.open(mos) as m:
imheader = m[0].header
naxis1.append(imheader['NAXIS1'])
naxis2.append(imheader['NAXIS2'])
impix = np.array(naxis1) * np.array(naxis2)
smim = allim[np.argmin(impix)]
# Reproject the rest of the images to this one
# Load the header of the reference image
hduref = pyfits.open(smim)[0]
hduref_hdr = hduref.header
# Reproject the other images to the reference
for image in allim:
hdu = pyfits.open(image)[0]
hdu_hdr = hdu.header
hduref_hdr['FREQ'] = hdu_hdr['FREQ']
repr_image = reproject_interp(hdu,
hduref_hdr,
return_footprint=False)
pyfits.writeto(image.replace('.fits', '_repr.fits'),
repr_image,
hduref_hdr,
overwrite=True)
for image_uncorr in allim_uncorr:
hdu_uncorr = pyfits.open(image_uncorr)[0]
hdu_hdr_uncorr = hdu_uncorr.header
hduref_hdr['FREQ'] = hdu_hdr_uncorr['FREQ']
repr_image_uncorr = reproject_interp(hdu_uncorr,
hduref_hdr,
return_footprint=False)
pyfits.writeto(image_uncorr.replace('.fits', '_repr.fits'),
repr_image_uncorr,
hduref_hdr,
overwrite=True)
# Generate a mask to limit the valid area for all images to the largest common valid one
allreprims = sorted(glob.glob(self.polmosaicdir + '/*_repr.fits'))
nall = len(allreprims)
# Generate an array for all the images
alldata = np.full((nall, hduref_hdr['NAXIS2'], hduref_hdr['NAXIS1']),
np.nan)
for i, image in enumerate(allreprims):
hdu = pyfits.open(image)[0]
hdu_data = hdu.data
alldata[i, :, :] = hdu_data
# Generate the mask
immask = np.sum(alldata, axis=0)
immask[np.isfinite(immask)] = 1.0
# Apply the mask
for m, mimage in enumerate(allreprims):
mhdu = pyfits.open(mimage)[0]
mhdu_data = mhdu.data
mhdu_hdr = mhdu.header
mdata = mhdu_data * immask
pyfits.writeto(mimage.replace('_repr.fits', '_mask.fits'),
mdata,
mhdu_hdr,
overwrite=True)
# Finally create the frequency image cubes
qfinimages = sorted(glob.glob(self.polmosaicdir + '/*Q_mask.fits'))
ufinimages = sorted(glob.glob(self.polmosaicdir + '/*U_mask.fits'))
qfinimages_uncorr = sorted(
glob.glob(self.polmosaicdir + '/*Q_uncorr_mask.fits'))
ufinimages_uncorr = sorted(
glob.glob(self.polmosaicdir + '/*U_uncorr_mask.fits'))
nq = len(qfinimages)
nu = len(ufinimages)
nq_uncorr = len(qfinimages_uncorr)
nu_uncorr = len(ufinimages_uncorr)
qdata = np.full((nq, hduref_hdr['NAXIS2'], hduref_hdr['NAXIS1']),
np.nan)
udata = np.full((nu, hduref_hdr['NAXIS2'], hduref_hdr['NAXIS1']),
np.nan)
qdata_uncorr = np.full(
(nq_uncorr, hduref_hdr['NAXIS2'], hduref_hdr['NAXIS1']), np.nan)
udata_uncorr = np.full(
(nu_uncorr, hduref_hdr['NAXIS2'], hduref_hdr['NAXIS1']), np.nan)
freqs = []
freqs_uncorr = []
# Generate the Q cube
for q, qim in enumerate(qfinimages):
qhdu = pyfits.open(qim)[0]
qhdu_data = qhdu.data
qhdu_hdr = qhdu.header
freqs.append(qhdu_hdr['FREQ'])
qdata[q, :, :] = qhdu_data
qhdu_hdr.insert('NAXIS2', ('NAXIS3', len(qfinimages)), after=True)
qhdu_hdr.insert('CTYPE2', ('CRPIX3', 1.0), after=True)
qhdu_hdr.insert('CRPIX3', ('CDELT3', 6250000.0), after=True)
qhdu_hdr.insert('CDELT3', ('CRVAL3', freqs[0]), after=True)
qhdu_hdr.insert('CRVAL3', ('CTYPE3', 'FREQ-OBS'), after=True)
pyfits.writeto(self.polmosaicdir + '/Qcube.fits',
np.float32(qdata),
qhdu_hdr,
overwrite=True)
for q_uncorr, qim_uncorr in enumerate(qfinimages_uncorr):
qhdu_uncorr = pyfits.open(qim_uncorr)[0]
qhdu_data_uncorr = qhdu_uncorr.data
qhdu_hdr_uncorr = qhdu_uncorr.header
freqs_uncorr.append(qhdu_hdr_uncorr['FREQ'])
qdata_uncorr[q_uncorr, :, :] = qhdu_data_uncorr
qhdu_hdr_uncorr.insert('NAXIS2', ('NAXIS3', len(qfinimages_uncorr)),
after=True)
qhdu_hdr_uncorr.insert('CTYPE2', ('CRPIX3', 1.0), after=True)
qhdu_hdr_uncorr.insert('CRPIX3', ('CDELT3', 6250000.0), after=True)
qhdu_hdr_uncorr.insert('CDELT3', ('CRVAL3', freqs_uncorr[0]),
after=True)
qhdu_hdr_uncorr.insert('CRVAL3', ('CTYPE3', 'FREQ-OBS'), after=True)
pyfits.writeto(self.polmosaicdir + '/Qcube_uncorr.fits',
np.float32(qdata_uncorr),
qhdu_hdr_uncorr,
overwrite=True)
# Generate the U cube
for u, uim in enumerate(ufinimages):
uhdu = pyfits.open(uim)[0]
uhdu_data = uhdu.data
uhdu_hdr = uhdu.header
udata[u, :, :] = uhdu_data
uhdu_hdr.insert('NAXIS2', ('NAXIS3', len(ufinimages)), after=True)
uhdu_hdr.insert('CTYPE2', ('CRPIX3', 1.0), after=True)
uhdu_hdr.insert('CRPIX3', ('CDELT3', 6250000.0), after=True)
uhdu_hdr.insert('CDELT3', ('CRVAL3', freqs[0]), after=True)
uhdu_hdr.insert('CRVAL3', ('CTYPE3', 'FREQ-OBS'), after=True)
pyfits.writeto(self.polmosaicdir + '/Ucube.fits',
np.float32(udata),
uhdu_hdr,
overwrite=True)
for u_uncorr, uim_uncorr in enumerate(ufinimages_uncorr):
uhdu_uncorr = pyfits.open(uim_uncorr)[0]
uhdu_data_uncorr = uhdu_uncorr.data
uhdu_hdr_uncorr = uhdu_uncorr.header
udata_uncorr[u_uncorr, :, :] = uhdu_data_uncorr
uhdu_hdr_uncorr.insert('NAXIS2', ('NAXIS3', len(ufinimages_uncorr)),
after=True)
uhdu_hdr_uncorr.insert('CTYPE2', ('CRPIX3', 1.0), after=True)
uhdu_hdr_uncorr.insert('CRPIX3', ('CDELT3', 6250000.0), after=True)
uhdu_hdr_uncorr.insert('CDELT3', ('CRVAL3', freqs_uncorr[0]),
after=True)
uhdu_hdr_uncorr.insert('CRVAL3', ('CTYPE3', 'FREQ-OBS'), after=True)
pyfits.writeto(self.polmosaicdir + '/Ucube_uncorr.fits',
np.float32(udata_uncorr),
uhdu_hdr_uncorr,
overwrite=True)
# Write the frequency file
with open(self.polmosaicdir + '/freq.txt', 'w') as f:
for item in freqs:
f.write("%s\n" % item)
# Write a file with the central coordinates of each pointing used
coord_arr = np.full((40, 3), np.nan)
coord_arr[:, 0] = np.arange(0, 40, 1)
for b in range(40):
if os.path.isfile(
os.path.join(self.basedir, self.obsid,
str(b).zfill(2), 'polarisation/Qcube.fits')):
qcube = pyfits.open(
os.path.join(self.basedir, self.obsid,
str(b).zfill(2),
'polarisation/Qcube.fits'))[0]
qcube_hdr = qcube.header
coord_arr[b, 1] = qcube_hdr['CRVAL1']
coord_arr[b, 2] = qcube_hdr['CRVAL2']
np.savetxt(self.polmosaicdir + '/pointings.txt',
coord_arr,
fmt=['%2s', '%1.13e', '%1.13e'],
delimiter='\t')
# Remove obsolete files
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_Q_mask.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_U_mask.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_Q_repr.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_U_repr.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_Q.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_U.fits')
os.system('rm -rf ' + self.polmosaicdir +
'*_[0-9][0-9]_Q_uncorr_mask.fits')
os.system('rm -rf ' + self.polmosaicdir +
'*_[0-9][0-9]_U_uncorr_mask.fits')
os.system('rm -rf ' + self.polmosaicdir +
'*_[0-9][0-9]_Q_uncorr_repr.fits')
os.system('rm -rf ' + self.polmosaicdir +
'*_[0-9][0-9]_U_uncorr_repr.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_Q_uncorr.fits')
os.system('rm -rf ' + self.polmosaicdir + '*_[0-9][0-9]_U_uncorr.fits')
def make_polmosaic(self,
qimages,
uimages,
pbimages,
sb,
psf,
reference=None,
pbclip=None):
"""
Function to generate the polarisation mosaic in Q and U
"""
# Set the directories for the mosaicking
utils.set_mosdirs(self)
# Get the common psf
common_psf = psf
qcorrimages = [] # to mosaic
ucorrimages = [] # to mosaic
quncorrimages = [] # to mosaic
uuncorrimages = [] # to mosaic
qpbweights = [] # of the pixels
upbweights = [] # of the pixels
qfreqs = []
ufreqs = []
# weight_images = []
for qimg, uimg, pb in zip(qimages, uimages, pbimages):
# prepare the images (squeeze, transfer_coordinates, reproject, regrid pbeam, correct...)
with pyfits.open(qimg) as f:
qimheader = f[0].header
qfreqs.append(qimheader['CRVAl3'])
qtg = qimheader['OBJECT']
with pyfits.open(uimg) as f:
uimheader = f[0].header
ufreqs.append(uimheader['CRVAl3'])
utg = uimheader['OBJECT']
# convolution with the common psf
qreconvolved_image = qimg.replace('.fits', '_reconv_tmp.fits')
qreconvolved_image = fm.fits_reconvolve_psf(qimg,
common_psf,
out=qreconvolved_image)
ureconvolved_image = uimg.replace('.fits', '_reconv_tmp.fits')
ureconvolved_image = fm.fits_reconvolve_psf(uimg,
common_psf,
out=ureconvolved_image)
# PB correction
qtmpimg = utils.make_tmp_copy(qreconvolved_image)
utmpimg = utils.make_tmp_copy(ureconvolved_image)
qtmppb = utils.make_tmp_copy(pb)
utmppb = utils.make_tmp_copy(pb)
qtmpimg = fm.fits_squeeze(qtmpimg) # remove extra dimentions
utmpimg = fm.fits_squeeze(utmpimg) # remove extra dimentions
qtmppb = fm.fits_transfer_coordinates(
qtmpimg, qtmppb) # transfer_coordinates
utmppb = fm.fits_transfer_coordinates(
utmpimg, utmppb) # transfer_coordinates
qtmppb = fm.fits_squeeze(qtmppb) # remove extra dimentions
utmppb = fm.fits_squeeze(utmppb) # remove extra dimentions
with pyfits.open(qtmpimg) as qf:
qimheader = qf[0].header
with pyfits.open(qtmppb) as qf:
qpbhdu = qf[0]
qpbheader = qf[0].header
qpbarray = qf[0].data
if (qimheader['CRVAL1'] != qpbheader['CRVAL1']) or (
qimheader['CRVAL2'] != qpbheader['CRVAL2']) or (
qimheader['CDELT1'] != qpbheader['CDELT1']) or (
qimheader['CDELT2'] != qpbheader['CDELT2']):
qpbarray, qreproj_footprint = reproject_interp(
qpbhdu, qimheader)
else:
pass
with pyfits.open(utmpimg) as uf:
uimheader = uf[0].header
with pyfits.open(utmppb) as uf:
upbhdu = uf[0]
upbheader = uf[0].header
upbarray = uf[0].data
if (uimheader['CRVAL1'] != upbheader['CRVAL1']) or (
uimheader['CRVAL2'] != upbheader['CRVAL2']) or (
uimheader['CDELT1'] != upbheader['CDELT1']) or (
uimheader['CDELT2'] != upbheader['CDELT2']):
upbarray, ureproj_footprint = reproject_interp(
upbhdu, uimheader)
else:
pass
qpbarray = np.float32(qpbarray)
upbarray = np.float32(upbarray)
qpbarray[qpbarray < self.pol_pbclip] = np.nan
upbarray[upbarray < self.pol_pbclip] = np.nan
qpb_regr_repr = qtmppb.replace('_tmp.fits', '_repr_tmp.fits')
upb_regr_repr = utmppb.replace('_tmp.fits', '_repr_tmp.fits')
pyfits.writeto(qpb_regr_repr, qpbarray, qimheader, overwrite=True)
pyfits.writeto(upb_regr_repr, upbarray, uimheader, overwrite=True)
qimg_corr = qreconvolved_image.replace('.fits', '_pbcorr.fits')
uimg_corr = ureconvolved_image.replace('.fits', '_pbcorr.fits')
qimg_uncorr = qreconvolved_image.replace('.fits', '_uncorr.fits')
uimg_uncorr = ureconvolved_image.replace('.fits', '_uncorr.fits')
qimg_corr = fm.fits_operation(qtmpimg,
qpbarray,
operation='/',
out=qimg_corr)
uimg_corr = fm.fits_operation(utmpimg,
upbarray,
operation='/',
out=uimg_corr)
qimg_uncorr = fm.fits_operation(qimg_corr,
qpbarray,
operation='*',
out=qimg_uncorr)
uimg_uncorr = fm.fits_operation(uimg_corr,
upbarray,
operation='*',
out=uimg_uncorr)
# cropping
qcropped_image = qimg.replace('.fits', '_mos.fits')
ucropped_image = uimg.replace('.fits', '_mos.fits')
qcropped_image, qcutout = fm.fits_crop(qimg_corr,
out=qcropped_image)
ucropped_image, ucutout = fm.fits_crop(uimg_corr,
out=ucropped_image)
quncorr_cropped_image = qimg.replace('.fits', '_uncorr.fits')
uuncorr_cropped_image = uimg.replace('.fits', '_uncorr.fits')
quncorr_cropped_image, _ = fm.fits_crop(qimg_uncorr,
out=quncorr_cropped_image)
uuncorr_cropped_image, _ = fm.fits_crop(uimg_uncorr,
out=uuncorr_cropped_image)
qcorrimages.append(qcropped_image)
ucorrimages.append(ucropped_image)
quncorrimages.append(quncorr_cropped_image)
uuncorrimages.append(uuncorr_cropped_image)
# primary beam weights
qwg_arr = qpbarray #
qwg_arr[np.isnan(qwg_arr)] = 0 # the NaNs weight 0
qwg_arr = qwg_arr**2 / np.nanmax(qwg_arr**2) # normalize
qwcut = Cutout2D(qwg_arr, qcutout.input_position_original,
qcutout.shape)
qpbweights.append(qwcut.data)
uwg_arr = upbarray #
uwg_arr[np.isnan(uwg_arr)] = 0 # the NaNs weight 0
uwg_arr = uwg_arr**2 / np.nanmax(uwg_arr**2) # normalize
uwcut = Cutout2D(uwg_arr, ucutout.input_position_original,
ucutout.shape)
upbweights.append(uwcut.data)
# create the wcs and footprint for the output mosaic
print(
'Generating primary beam corrected and uncorrected polarisation mosaics for Stokes Q and U for subband '
+ str(sb).zfill(2) + '.')
qwcs_out, qshape_out = find_optimal_celestial_wcs(qcorrimages,
auto_rotate=False,
reference=reference)
uwcs_out, ushape_out = find_optimal_celestial_wcs(ucorrimages,
auto_rotate=False,
reference=reference)
qarray, qfootprint = reproject_and_coadd(
qcorrimages,
qwcs_out,
shape_out=qshape_out,
reproject_function=reproject_interp,
input_weights=qpbweights)
uarray, ufootprint = reproject_and_coadd(
ucorrimages,
uwcs_out,
shape_out=ushape_out,
reproject_function=reproject_interp,
input_weights=upbweights)
qarray2, q_ = reproject_and_coadd(quncorrimages,
qwcs_out,
shape_out=qshape_out,
reproject_function=reproject_interp,
input_weights=qpbweights)
uarray2, u_ = reproject_and_coadd(uuncorrimages,
uwcs_out,
shape_out=ushape_out,
reproject_function=reproject_interp,
input_weights=upbweights)
qarray = np.float32(qarray)
uarray = np.float32(uarray)
qarray2 = np.float32(qarray2)
uarray2 = np.float32(uarray2)
# insert common PSF into the header
qpsf = common_psf.to_header_keywords()
upsf = common_psf.to_header_keywords()
qhdr = qwcs_out.to_header()
uhdr = uwcs_out.to_header()
qhdr.insert('RADESYS', ('FREQ', np.nanmean(qfreqs)))
uhdr.insert('RADESYS', ('FREQ', np.nanmean(ufreqs)))
qhdr.insert('RADESYS', ('BMAJ', qpsf['BMAJ']))
uhdr.insert('RADESYS', ('BMAJ', upsf['BMAJ']))
qhdr.insert('RADESYS', ('BMIN', qpsf['BMIN']))
uhdr.insert('RADESYS', ('BMIN', upsf['BMIN']))
qhdr.insert('RADESYS', ('BPA', qpsf['BPA']))
uhdr.insert('RADESYS', ('BPA', upsf['BPA']))
# insert units to header:
qhdr.insert('RADESYS', ('BUNIT', 'JY/BEAM'))
uhdr.insert('RADESYS', ('BUNIT', 'JY/BEAM'))
pyfits.writeto(self.polmosaicdir + '/' + str(qtg).upper() + '_' +
str(sb).zfill(2) + '_Q.fits',
data=qarray,
header=qhdr,
overwrite=True)
pyfits.writeto(self.polmosaicdir + '/' + str(utg).upper() + '_' +
str(sb).zfill(2) + '_U.fits',
data=uarray,
header=uhdr,
overwrite=True)
pyfits.writeto(self.polmosaicdir + '/' + str(qtg).upper() + '_' +
str(sb).zfill(2) + '_Q_uncorr.fits',
data=qarray2,
header=qhdr,
overwrite=True)
pyfits.writeto(self.polmosaicdir + '/' + str(utg).upper() + '_' +
str(sb).zfill(2) + '_U_uncorr.fits',
data=uarray2,
header=uhdr,
overwrite=True)
utils.clean_polmosaic_tmp_data(self)
def __init__(self, file_=None, **kwargs):
self.default = utils.load_config(self, file_)
utils.set_mosdirs(self)
self.config_file_name = file_
def make_polmosaic(self,
qimages,
uimages,
pbimages,
sb,
psf,
reference=None,
pbclip=None):
"""
Function to generate the polarisation mosaic in Q and U
"""
# Set the directories for the mosaicking
utils.set_mosdirs(self)
# Get the common psf
common_psf = psf
qcorrimages = [] # to mosaic
ucorrimages = [] # to mosaic
qpbweights = [] # of the pixels
upbweights = [] # of the pixels
qrmsweights = [] # of the images themself
urmsweights = [] # of the images themself
qfreqs = []
ufreqs = []
# weight_images = []
for qimg, uimg, pb in zip(qimages, uimages, pbimages):
# prepare the images (squeeze, transfer_coordinates, reproject, regrid pbeam, correct...)
with pyfits.open(qimg) as f:
qimheader = f[0].header
qfreqs.append(qimheader['CRVAl3'])
qtg = qimheader['OBJECT']
with pyfits.open(uimg) as f:
uimheader = f[0].header
ufreqs.append(uimheader['CRVAl3'])
utg = uimheader['OBJECT']
qimg = fm.fits_squeeze(qimg) # remove extra dimentions
uimg = fm.fits_squeeze(uimg) # remove extra dimentions
pb = fm.fits_transfer_coordinates(qimg, pb) # transfer_coordinates
pb = fm.fits_squeeze(pb) # remove extra dimensions
with pyfits.open(qimg) as f:
qimheader = f[0].header
qimdata = f[0].data
with pyfits.open(uimg) as f:
uimheader = f[0].header
uimdata = f[0].data
with pyfits.open(pb) as f:
pbhdu = f[0]
autoclip = np.nanmin(f[0].data)
# reproject
qreproj_arr, qreproj_footprint = reproject_interp(
pbhdu, qimheader)
ureproj_arr, ureproj_footprint = reproject_interp(
pbhdu, uimheader)
pbclip = self.pol_pbclip or autoclip
print('PB is clipped at %f level', pbclip)
qreproj_arr = np.float32(qreproj_arr)
ureproj_arr = np.float32(ureproj_arr)
qreproj_arr[qreproj_arr < pbclip] = np.nan
ureproj_arr[ureproj_arr < pbclip] = np.nan
qpb_regr_repr = pb.replace('.fits', '_repr.fits')
upb_regr_repr = pb.replace('.fits', '_repr.fits')
pyfits.writeto(qpb_regr_repr,
qreproj_arr,
qimheader,
overwrite=True)
pyfits.writeto(upb_regr_repr,
ureproj_arr,
uimheader,
overwrite=True)
# convolution with common psf
qreconvolved_image = qimg.replace('.fits', '_reconv.fits')
qreconvolved_image = fm.fits_reconvolve_psf(qimg,
common_psf,
out=qreconvolved_image)
ureconvolved_image = uimg.replace('.fits', '_reconv.fits')
ureconvolved_image = fm.fits_reconvolve_psf(uimg,
common_psf,
out=ureconvolved_image)
# PB correction
qpbcorr_image = qreconvolved_image.replace('_reconv.fits',
'_pbcorr.fits')
qpbcorr_image = fm.fits_operation(qreconvolved_image,
qreproj_arr,
operation='/',
out=qpbcorr_image)
upbcorr_image = ureconvolved_image.replace('_reconv.fits',
'_pbcorr.fits')
upbcorr_image = fm.fits_operation(ureconvolved_image,
ureproj_arr,
operation='/',
out=upbcorr_image)
# cropping
qcropped_image = qimg.replace('.fits', '_mos.fits')
qcropped_image, qcutout = fm.fits_crop(qpbcorr_image,
out=qcropped_image)
qcorrimages.append(qcropped_image)
ucropped_image = uimg.replace('.fits', '_mos.fits')
ucropped_image, ucutout = fm.fits_crop(upbcorr_image,
out=ucropped_image)
ucorrimages.append(ucropped_image)
# primary beam weights
qwg_arr = qreproj_arr - pbclip # the edges weight ~0
qwg_arr[np.isnan(qwg_arr)] = 0 # the NaNs weight 0
qwg_arr = qwg_arr / np.nanmax(qwg_arr) # normalize
qwcut = Cutout2D(qwg_arr, qcutout.input_position_original,
qcutout.shape)
qpbweights.append(qwcut.data)
uwg_arr = ureproj_arr - pbclip # the edges weight ~0
uwg_arr[np.isnan(uwg_arr)] = 0 # the NaNs weight 0
uwg_arr = uwg_arr / np.nanmax(uwg_arr) # normalize
uwcut = Cutout2D(uwg_arr, ucutout.input_position_original,
ucutout.shape)
upbweights.append(uwcut.data)
# weight the images by RMS noise over the edges
ql, qm = qimdata.shape[0] // 10, qimdata.shape[1] // 10
qmask = np.ones(qimdata.shape, dtype=np.bool)
qmask[ql:-ql, qm:-qm] = False
qimg_noise = np.nanstd(qimdata[qmask])
qimg_weight = 1 / qimg_noise**2
qrmsweights.append(qimg_weight)
ul, um = uimdata.shape[0] // 10, uimdata.shape[1] // 10
umask = np.ones(uimdata.shape, dtype=np.bool)
umask[ul:-ul, um:-um] = False
uimg_noise = np.nanstd(uimdata[umask])
uimg_weight = 1 / uimg_noise**2
urmsweights.append(uimg_weight)
# merge the image rms weights and the primary beam pixel weights:
qweights = [
qp * qr / max(qrmsweights)
for qp, qr in zip(qpbweights, qrmsweights)
]
uweights = [
up * ur / max(urmsweights)
for up, ur in zip(upbweights, urmsweights)
]
# create the wcs and footprint for the output mosaic
qwcs_out, qshape_out = find_optimal_celestial_wcs(qcorrimages,
auto_rotate=False,
reference=reference)
uwcs_out, ushape_out = find_optimal_celestial_wcs(ucorrimages,
auto_rotate=False,
reference=reference)
qarray, qfootprint = reproject_and_coadd(
qcorrimages,
qwcs_out,
shape_out=qshape_out,
reproject_function=reproject_interp,
input_weights=qweights)
uarray, ufootprint = reproject_and_coadd(
ucorrimages,
uwcs_out,
shape_out=ushape_out,
reproject_function=reproject_interp,
input_weights=uweights)
qarray = np.float32(qarray)
uarray = np.float32(uarray)
# insert common PSF into the header
qpsf = common_psf.to_header_keywords()
qhdr = qwcs_out.to_header()
qhdr.insert('RADESYS', ('FREQ', np.nanmean(qfreqs)))
qhdr.insert('RADESYS', ('BMAJ', qpsf['BMAJ']))
qhdr.insert('RADESYS', ('BMIN', qpsf['BMIN']))
qhdr.insert('RADESYS', ('BPA', qpsf['BPA']))
upsf = common_psf.to_header_keywords()
uhdr = qwcs_out.to_header()
uhdr.insert('RADESYS', ('FREQ', np.nanmean(ufreqs)))
uhdr.insert('RADESYS', ('BMAJ', upsf['BMAJ']))
uhdr.insert('RADESYS', ('BMIN', upsf['BMIN']))
uhdr.insert('RADESYS', ('BPA', upsf['BPA']))
pyfits.writeto(self.polmosaicdir + '/' + str(qtg).upper() + '_' +
str(sb).zfill(2) + '_Q.fits',
data=qarray,
header=qhdr,
overwrite=True)
pyfits.writeto(self.polmosaicdir + '/' + str(utg).upper() + '_' +
str(sb).zfill(2) + '_U.fits',
data=uarray,
header=uhdr,
overwrite=True)
utils.clean_polmosaic_tmp_data(self, sb)