def get_theoretical_noise(self, dataset, gausslimit, startchan=None, endchan=None):
"""
Subroutine to create a Stokes V image from a dataset and measure the noise, which should be similar to the theoretical one
image (string): The path to the dataset file.
startchan(int): First channel to use for imaging, zero-based
endchan(int): Last channel to use for imaging, zero-based
returns (numpy array): The rms of the image
"""
invert = lib.miriad('invert')
invert.vis = dataset
invert.map = 'vrms'
invert.beam = 'vbeam'
invert.imsize = 1024
invert.cell = 5
invert.stokes = 'v'
invert.slop = 1
invert.robust = -2
invert.options='mfs'
if (startchan and endchan) != None:
invert.line = 'channel,1,' + str(startchan + 1) + ',' + str(endchan - startchan + 1) + ',' + str(endchan - startchan + 1)
else:
pass
invert.go()
vmax, vmin, vstd = imstats.getimagestats(self, 'vrms')
gaussianity = qa.checkimagegaussianity(self, 'vrms', gausslimit)
if os.path.isdir('vrms') and os.path.isdir('vbeam'):
managefiles.director(self, 'rm', 'vrms')
managefiles.director(self, 'rm', 'vbeam')
else:
raise ApercalException('Stokes V image was not created successfully. Cannot calculate theoretical noise! No iterative selfcal possible!')
return gaussianity, vstd
def checkmodelpolimage(self, image):
"""
Subroutine to check if a model image is valid
image (string): The path/name of the image to check
returns (boolean): True if image is ok, False otherwise
"""
modelstats = imstats.getimagestats(self, image)
if modelstats[2] != np.nan and modelstats[1] <= 1000 and modelstats[0] >= -10.0:
return True
else:
return False
def checkmaskimage(self, image):
"""
Checks if a mask is completely blanked.
image: The input mask to check
return: True if mask is not blank
"""
maskstats = imstats.getimagestats(self, image)
if np.isnan(maskstats[0]) or np.isnan(maskstats[1]) or np.isnan(maskstats[2]):
return False
else:
return True
def checkdirtyimage(self, image):
"""
Subroutine to check if a dirty image is valid
image (string): The path/name of the image to check
returns (boolean): True if image is ok, False otherwise
"""
dirtystats = imstats.getimagestats(self, image)
if (dirtystats[1] >= dirtystats[0]) and (dirtystats[2] != np.nan):
return True
else:
return False
def mosaic_continuum_mf(self):
"""Looks for all available stacked continuum images and mosaics them into one large image."""
subs_setinit.setinitdirs(self)
subs_setinit.setdatasetnamestomiriad(self)
##########################################################################################################
# Check if the parameter is already in the parameter file and load it otherwise create the needed arrays #
##########################################################################################################
mosaiccontinuummfstatus = get_param_def(
self, 'mosaic_continuum_mf_status',
False) # Status of the continuum mf mosaic
mosaiccontinuummfcontinuumstatus = get_param_def(
self, 'mosaic_continuum_mf_continuumstatus',
np.full(self.NBEAMS, False)) # Status of the continuum imaging
mosaiccontinuummfcopystatus = get_param_def(
self, 'mosaic_continuum_mf_copystatus',
np.full(self.NBEAMS, False)) # Status of the copy of the images
mosaiccontinuummfconvolstatus = get_param_def(
self, 'mosaic_continuum_mf_convolstatus',
np.full(self.NBEAMS, False)) # Status of the convolved images
mosaiccontinuummfcontinuumbeamparams = get_param_def(
self, 'mosaic_continuum_mf_continuumbeamparams',
np.full((self.NBEAMS, 3),
np.nan)) # Beam sizes of the input images
mosaiccontinuummfcontinuumimagestats = get_param_def(
self, 'mosaic_continuum_mf_continuumimagestats',
np.full((self.NBEAMS, 3),
np.nan)) # Image statistics of the input images
# Start the mosaicking of the stacked continuum images
if self.mosaic_continuum_mf:
subs_setinit.setinitdirs(self)
subs_setinit.setdatasetnamestomiriad(self)
subs_managefiles.director(self, 'ch', self.mosdir + '/continuum')
if not mosaiccontinuummfstatus:
logger.info('Mosaicking multi-frequency continuum images')
# Acquire the results and statistics from continuum mf imaging
for b in range(self.NBEAMS):
mosaiccontinuummfcontinuumstatus[b] = get_param_def(
self, 'continuum_B' + str(b).zfill(2) +
'_targetbeams_mf_status', False)
if mosaiccontinuummfcontinuumstatus[b]:
finalminor = get_param_def(
self, 'continuum_B' + str(b).zfill(2) +
'_targetbeams_mf_final_minorcycle', np.nan)
subs_managefiles.director(
self,
'cp',
str(b).zfill(2) + '.fits',
file_=self.basedir + str(b).zfill(2) + '/' +
self.contsubdir + '/' + 'image_mf_' +
str(finalminor).zfill(2) + '.fits')
if os.path.isfile(str(b).zfill(2) + '.fits'):
mosaiccontinuummfcopystatus[b] = True
subs_convim.fitstomir(
str(b).zfill(2) + '.fits',
str(b).zfill(2))
subs_managefiles.director(
self, 'rm',
str(b).zfill(2) + '.fits')
else:
mosaiccontinuummfcopystatus[b] = False
logger.warning('Beam ' + str(b).zfill(2) +
' was not copied successfully!')
# Copy the images over to the mosaic directory
for b in range(self.NBEAMS):
if mosaiccontinuummfcontinuumstatus[
b] and mosaiccontinuummfcopystatus[b]:
# Get the image beam parameters and the image statistics
mosaiccontinuummfcontinuumimagestats[
b, :] = subs_imstats.getimagestats(
self,
str(b).zfill(2))
mosaiccontinuummfcontinuumbeamparams[
b, :] = subs_readmirhead.getbeamimage(
str(b).zfill(2))
else:
logger.warning(
'Skipping Beam ' + str(b).zfill(2) +
'! Continuum mf-imaging was not successful or continuum image not available!'
)
# Calculate the synthesised beam and reject outliers (algorithm needs to be updated)
rejbeams, beamparams = subs_combim.calc_synbeam(
mosaiccontinuummfcontinuumbeamparams)
# Convolve all the images to the calculated beam
for b in range(self.NBEAMS):
if mosaiccontinuummfcontinuumstatus[
b] and mosaiccontinuummfcopystatus[b]:
try:
convol = lib.miriad('convol')
convol.map = str(b).zfill(2)
convol.fwhm = str(beamparams[0]) + ',' + str(
beamparams[1])
convol.pa = str(beamparams[2])
convol.options = 'final'
convol.out = str(b).zfill(2) + '_cv'
convol.go()
if os.path.isdir(str(b).zfill(2) + '_cv'):
mosaiccontinuummfconvolstatus[b] = True
else:
mosaiccontinuummfconvolstatus[b] = False
logger.warning(
'Beam ' + str(b).zfill(2) +
' could not be convolved to the calculated beam size! File not there!'
)
except:
mosaiccontinuummfconvolstatus[b] = False
logger.warning(
'Beam ' + str(b).zfill(2) +
' could not be convolved to the calculated beam size!'
)
# Combine all the images using linmos (needs to be updated with proper primary beam model)
linmosimages = ''
linmosrms = ''
for b in range(self.NBEAMS):
if mosaiccontinuummfcontinuumstatus[
b] and mosaiccontinuummfcopystatus[
b] and mosaiccontinuummfconvolstatus[b]:
linmosimages = linmosimages + str(b).zfill(2) + '_cv,'
linmosrms = linmosrms + str(
subs_imstats.getimagestats(
self,
str(b).zfill(2) + '_cv')[2]) + ','
linmos = lib.miriad('linmos')
linmos.in_ = linmosimages.rstrip(',')
linmos.rms = linmosrms.rstrip(',')
linmos.out = self.target.rstrip('.MS') + '_mf'
linmos.go()
if os.path.isdir(self.target.rstrip('.MS') + '_mf'):
mosaiccontinuummfstatus = True
subs_convim.mirtofits(
self.target.rstrip('.MS') + '_mf',
self.target.rstrip('.MS') + '_mf.fits')
logger.info(
'Mosaicking of multi-frequency image successful!')
else:
mosaiccontinuummfstatus = False
logger.error(
'Multi-freqeuncy mosaic was not created successfully!')
else:
mosaiccontinuummfstatus = True
logger.info(
'Multi-frequency continuum mosaic was already successfully created!'
)
# Save the derived parameters to the parameter file
subs_param.add_param(self, 'mosaic_continuum_mf_status',
mosaiccontinuummfstatus)
subs_param.add_param(self, 'mosaic_continuum_mf_continuumstatus',
mosaiccontinuummfcontinuumstatus)
subs_param.add_param(self, 'mosaic_continuum_mf_copystatus',
mosaiccontinuummfcopystatus)
subs_param.add_param(self, 'mosaic_continuum_mf_convolstatus',
mosaiccontinuummfconvolstatus)
subs_param.add_param(self, 'mosaic_continuum_mf_continuumbeamparams',
mosaiccontinuummfcontinuumbeamparams)
subs_param.add_param(self, 'mosaic_continuum_mf_continuumimagestats',
mosaiccontinuummfcontinuumimagestats)