def generic_map():
data = np.arange(36, dtype=np.float64).reshape((6, 6))
dobs = Time('1970-01-01T00:00:00')
l0 = sun.L0(dobs).to_value(u.deg)
b0 = sun.B0(dobs).to_value(u.deg)
dsun = sun.earth_distance(dobs).to_value(u.m)
header = {
'CRVAL1': 0,
'CRVAL2': 0,
'CRPIX1': 5,
'CRPIX2': 5,
'CDELT1': 10,
'CDELT2': 10,
'CUNIT1': 'arcsec',
'CUNIT2': 'arcsec',
'CTYPE1': 'HPLN-TAN',
'CTYPE2': 'HPLT-TAN',
'PC1_1': 0,
'PC1_2': -1,
'PC2_1': 1,
'PC2_2': 0,
'NAXIS1': 6,
'NAXIS2': 6,
'date-obs': dobs.isot,
'crln_obs': l0,
'crlt_obs': b0,
"dsun_obs": dsun,
'mjd-obs': 40587.0,
'obsrvtry': 'Foo',
'detector': 'bar',
'wavelnth': 10,
'waveunit': 'm',
'bunit': 'ct/s',
}
return sunpy.map.Map((data, header))
def test_heliographic_longitude_crln(hmi_test_map):
assert_quantity_allclose(
hmi_test_map.heliographic_longitude,
hmi_test_map.carrington_longitude - sun.L0(hmi_test_map.date))
def test_carrington_longitude(generic_map):
with pytest.warns(
SunpyUserWarning,
match=
'Missing metadata for observer: assuming Earth-based observer.*'):
assert generic_map.carrington_longitude == sun.L0(generic_map.date)
def test_heliographic_longitude_crln(hmi_test_map):
assert_quantity_allclose(
hmi_test_map.heliographic_longitude,
hmi_test_map.carrington_longitude - sun.L0(hmi_test_map.date),
rtol=1e-3) # A tolerance is needed because L0 is for Earth, not SDO
def test_carrington_longitude(generic_map):
assert u.allclose(generic_map.carrington_longitude,
sun.L0(generic_map.date))
def imreg(vis=None,
ephem=None,
msinfo=None,
imagefile=None,
timerange=None,
reftime=None,
fitsfile=None,
beamfile=None,
offsetfile=None,
toTb=None,
sclfactor=1.0,
verbose=False,
p_ang=False,
overwrite=True,
usephacenter=True,
deletehistory=False,
subregion=[],
docompress=False):
'''
main routine to register CASA images
Required Inputs:
vis: STRING. CASA measurement set from which the image is derived
imagefile: STRING or LIST. name of the input CASA image
timerange: STRING or LIST. timerange used to generate the CASA image, must have the same length as the input images.
Each element should be in CASA standard time format, e.g., '2012/03/03/12:00:00~2012/03/03/13:00:00'
Optional Inputs:
msinfo: DICTIONARY. CASA MS information, output from read_msinfo. If not provided, generate one from the supplied vis
ephem: DICTIONARY. solar ephem, output from read_horizons.
If not provided, query JPL Horizons based on time info of the vis (internet connection required)
fitsfile: STRING or LIST. name of the output registered fits files
reftime: STRING or LIST. Each element should be in CASA standard time format, e.g., '2012/03/03/12:00:00'
offsetfile: optionally provide an offset with a series of solar x and y offsets with timestamps
toTb: Bool. Convert the default Jy/beam to brightness temperature?
sclfactor: scale the image values up by its value (to compensate VLA 20 dB attenuator)
verbose: Bool. Show more diagnostic info if True.
usephacenter: Bool -- if True, correct for the RA and DEC in the ms file based on solar empheris.
Otherwise assume the phasecenter is correctly pointed to the solar disk center
(EOVSA case)
subregion: Region selection. See 'help par.region' for details.
Usage:
>>> from suncasa.utils import helioimage2fits as hf
>>> hf.imreg(vis='mydata.ms', imagefile='myimage.image', fitsfile='myimage.fits',
timerange='2017/08/21/20:21:10~2017/08/21/20:21:18')
The output fits file is 'myimage.fits'
History:
BC (sometime in 2014): function was first wrote, followed by a number of edits by BC and SY
BC (2019-07-16): Added checks for stokes parameter. Verified that for converting from Jy/beam to brightness temperature,
the convention of 2*k_b*T should always be used. I.e., for unpolarized source, stokes I, RR, LL, XX, YY,
etc. in the output CASA images from (t)clean should all have same values of radio intensity
(in Jy/beam) and brightness temperature (in K).
'''
if deletehistory:
ms_clearhistory(vis)
if not imagefile:
raise ValueError('Please specify input image')
if not timerange:
raise ValueError('Please specify timerange of the input image')
if type(imagefile) == str:
imagefile = [imagefile]
if type(timerange) == str:
timerange = [timerange]
if not fitsfile:
fitsfile = [img + '.fits' for img in imagefile]
if type(fitsfile) == str:
fitsfile = [fitsfile]
nimg = len(imagefile)
if len(timerange) != nimg:
raise ValueError(
'Number of input images does not equal to number of timeranges!')
if len(fitsfile) != nimg:
raise ValueError(
'Number of input images does not equal to number of output fits files!'
)
nimg = len(imagefile)
if verbose:
print(str(nimg) + ' images to process...')
if reftime: # use as reference time to find solar disk RA and DEC to register the image, but not the actual timerange associated with the image
if type(reftime) == str:
reftime = [reftime] * nimg
if len(reftime) != nimg:
raise ValueError(
'Number of reference times does not match that of input images!'
)
helio = ephem_to_helio(vis,
ephem=ephem,
msinfo=msinfo,
reftime=reftime,
usephacenter=usephacenter)
else:
# use the supplied timerange to register the image
helio = ephem_to_helio(vis,
ephem=ephem,
msinfo=msinfo,
reftime=timerange,
usephacenter=usephacenter)
if toTb:
(bmajs, bmins, bpas, beamunits,
bpaunits) = getbeam(imagefile=imagefile, beamfile=beamfile)
for n, img in enumerate(imagefile):
if verbose:
print('processing image #' + str(n) + ' ' + img)
fitsf = fitsfile[n]
timeran = timerange[n]
# obtain duration of the image as FITS header exptime
try:
[tbg0, tend0] = timeran.split('~')
tbg_d = qa.getvalue(qa.convert(qa.totime(tbg0), 'd'))[0]
tend_d = qa.getvalue(qa.convert(qa.totime(tend0), 'd'))[0]
tdur_s = (tend_d - tbg_d) * 3600. * 24.
dateobs = qa.time(qa.quantity(tbg_d, 'd'), form='fits', prec=10)[0]
except:
print('Error in converting the input timerange: ' + str(timeran) +
'. Proceeding to the next image...')
continue
hel = helio[n]
if not os.path.exists(img):
warnings.warn('{} does not existed!'.format(img))
else:
if os.path.exists(fitsf) and not overwrite:
raise ValueError(
'Specified fits file already exists and overwrite is set to False. Aborting...'
)
else:
p0 = hel['p0']
tb.open(img + '/logtable', nomodify=False)
nobs = tb.nrows()
tb.removerows([i + 1 for i in range(nobs - 1)])
tb.close()
ia.open(img)
imr = ia.rotate(pa=str(-p0) + 'deg')
if subregion is not []:
imr = imr.subimage(region=subregion)
imr.tofits(fitsf, history=False, overwrite=overwrite)
imr.close()
imsum = ia.summary()
ia.close()
ia.done()
# construct the standard fits header
# RA and DEC of the reference pixel crpix1 and crpix2
(imra, imdec) = (imsum['refval'][0], imsum['refval'][1])
# find out the difference of the image center to the CASA phase center
# RA and DEC difference in arcseconds
ddec = degrees((imdec - hel['dec_fld'])) * 3600.
dra = degrees((imra - hel['ra_fld']) * cos(hel['dec_fld'])) * 3600.
# Convert into image heliocentric offsets
prad = -radians(hel['p0'])
dx = (-dra) * cos(prad) - ddec * sin(prad)
dy = (-dra) * sin(prad) + ddec * cos(prad)
if offsetfile:
try:
offset = np.load(offsetfile)
except:
raise ValueError(
'The specified offsetfile does not exist!')
reftimes_d = offset['reftimes_d']
xoffs = offset['xoffs']
yoffs = offset['yoffs']
timg_d = hel['reftime']
ind = bisect.bisect_left(reftimes_d, timg_d)
xoff = xoffs[ind - 1]
yoff = yoffs[ind - 1]
else:
xoff = hel['refx']
yoff = hel['refy']
if verbose:
print(
'offset of image phase center to visibility phase center (arcsec): dx={0:.2f}, dy={1:.2f}'
.format(dx, dy))
print(
'offset of visibility phase center to solar disk center (arcsec): dx={0:.2f}, dy={1:.2f}'
.format(xoff, yoff))
(crval1, crval2) = (xoff + dx, yoff + dy)
# update the fits header to heliocentric coordinates
hdu = pyfits.open(fitsf, mode='update')
hdu[0].verify('fix')
header = hdu[0].header
dshape = hdu[0].data.shape
ndim = hdu[0].data.ndim
(cdelt1,
cdelt2) = (-header['cdelt1'] * 3600., header['cdelt2'] * 3600.
) # Original CDELT1, 2 are for RA and DEC in degrees
header['cdelt1'] = cdelt1
header['cdelt2'] = cdelt2
header['cunit1'] = 'arcsec'
header['cunit2'] = 'arcsec'
header['crval1'] = crval1
header['crval2'] = crval2
header['ctype1'] = 'HPLN-TAN'
header['ctype2'] = 'HPLT-TAN'
header['date-obs'] = dateobs # begin time of the image
if not p_ang:
hel['p0'] = 0
try:
# this works for pyfits version of CASA 4.7.0 but not CASA 4.6.0
if tdur_s:
header.set('exptime', tdur_s)
else:
header.set('exptime', 1.)
header.set('p_angle', hel['p0'])
header.set('hgln_obs', 0.)
header.set('rsun_ref', sun.constants.radius.value)
if sunpyver <= 1:
header.set(
'dsun_obs',
sun.sunearth_distance(Time(dateobs)).to(u.meter).value)
header.set(
'rsun_obs',
sun.solar_semidiameter_angular_size(
Time(dateobs)).value)
header.set(
'hglt_obs',
sun.heliographic_solar_center(Time(dateobs))[1].value)
else:
header.set(
'dsun_obs',
sun.earth_distance(Time(dateobs)).to(u.meter).value)
header.set('rsun_obs',
sun.angular_radius(Time(dateobs)).value)
header.set('hglt_obs', sun.L0(Time(dateobs)).value)
except:
# this works for astropy.io.fits
if tdur_s:
header.append(('exptime', tdur_s))
else:
header.append(('exptime', 1.))
header.append(('p_angle', hel['p0']))
header.append(('hgln_obs', 0.))
header.append(('rsun_ref', sun.constants.radius.value))
if sunpyver <= 1:
header.append(
('dsun_obs', sun.sunearth_distance(Time(dateobs)).to(
u.meter).value))
header.append(('rsun_obs',
sun.solar_semidiameter_angular_size(
Time(dateobs)).value))
header.append(('hglt_obs',
sun.heliographic_solar_center(
Time(dateobs))[1].value))
else:
header.append(
('dsun_obs',
sun.earth_distance(Time(dateobs)).to(u.meter).value))
header.append(
('rsun_obs', sun.angular_radius(Time(dateobs)).value))
header.append(('hglt_obs', sun.L0(Time(dateobs)).value))
# check if stokes parameter exist
exist_stokes = False
stokes_mapper = {
'I': 1,
'Q': 2,
'U': 3,
'V': 4,
'RR': -1,
'LL': -2,
'RL': -3,
'LR': -4,
'XX': -5,
'YY': -6,
'XY': -7,
'YX': -8
}
if 'CRVAL3' in header.keys():
if header['CTYPE3'] == 'STOKES':
stokenum = header['CRVAL3']
exist_stokes = True
if 'CRVAL4' in header.keys():
if header['CTYPE4'] == 'STOKES':
stokenum = header['CRVAL4']
exist_stokes = True
if exist_stokes:
if stokenum in stokes_mapper.values():
stokesstr = list(stokes_mapper.keys())[list(
stokes_mapper.values()).index(stokenum)]
else:
print('Stokes parameter {0:d} not recognized'.format(
stokenum))
if verbose:
print('This image is in Stokes ' + stokesstr)
else:
print(
'STOKES Information does not seem to exist! Assuming Stokes I'
)
stokenum = 1
# intensity units to brightness temperature
if toTb:
# get restoring beam info
bmaj = bmajs[n]
bmin = bmins[n]
beamunit = beamunits[n]
data = hdu[
0].data # remember the data order is reversed due to the FITS convension
keys = list(header.keys())
values = list(header.values())
# which axis is frequency?
faxis = keys[values.index('FREQ')][-1]
faxis_ind = ndim - int(faxis)
# find out the polarization of this image
k_b = qa.constants('k')['value']
c_l = qa.constants('c')['value']
# Always use 2*kb for all polarizations
const = 2. * k_b / c_l**2
if header['BUNIT'].lower() == 'jy/beam':
header['BUNIT'] = 'K'
header['BTYPE'] = 'Brightness Temperature'
for i in range(dshape[faxis_ind]):
nu = header['CRVAL' +
faxis] + header['CDELT' + faxis] * (
i + 1 - header['CRPIX' + faxis])
if header['CUNIT' + faxis] == 'KHz':
nu *= 1e3
if header['CUNIT' + faxis] == 'MHz':
nu *= 1e6
if header['CUNIT' + faxis] == 'GHz':
nu *= 1e9
if len(bmaj) > 1: # multiple (per-plane) beams
bmajtmp = bmaj[i]
bmintmp = bmin[i]
else: # one single beam
bmajtmp = bmaj[0]
bmintmp = bmin[0]
if beamunit == 'arcsec':
bmaj0 = np.radians(bmajtmp / 3600.)
bmin0 = np.radians(bmintmp / 3600.)
if beamunit == 'arcmin':
bmaj0 = np.radians(bmajtmp / 60.)
bmin0 = np.radians(bmintmp / 60.)
if beamunit == 'deg':
bmaj0 = np.radians(bmajtmp)
bmin0 = np.radians(bmintmp)
if beamunit == 'rad':
bmaj0 = bmajtmp
bmin0 = bmintmp
beam_area = bmaj0 * bmin0 * np.pi / (4. * log(2.))
factor = const * nu**2 # SI unit
jy_to_si = 1e-26
# print(nu/1e9, beam_area, factor)
factor2 = sclfactor
# if sclfactor:
# factor2 = 100.
if faxis == '3':
data[:,
i, :, :] *= jy_to_si / beam_area / factor * factor2
if faxis == '4':
data[
i, :, :, :] *= jy_to_si / beam_area / factor * factor2
header = fu.headerfix(header)
hdu.flush()
hdu.close()
if ndim - np.count_nonzero(np.array(dshape) == 1) > 3:
docompress = False
'''
Caveat: only 1D, 2D, or 3D images are currently supported by
the astropy fits compression. If a n-dimensional image data array
does not have at least n-3 single-dimensional entries,
force docompress to be False
'''
print(
'warning: The fits data contains more than 3 non squeezable dimensions. Skipping fits compression..'
)
if docompress:
fitsftmp = fitsf + ".tmp.fits"
os.system("mv {} {}".format(fitsf, fitsftmp))
hdu = pyfits.open(fitsftmp)
hdu[0].verify('fix')
header = hdu[0].header
data = hdu[0].data
fu.write_compressed_image_fits(fitsf,
data,
header,
compression_type='RICE_1',
quantize_level=4.0)
os.system("rm -rf {}".format(fitsftmp))
if deletehistory:
ms_restorehistory(vis)
return fitsfile
def test_heliographic_longitude_crln(hmi_test_map):
assert hmi_test_map.heliographic_longitude == hmi_test_map.carrington_longitude - \
sun.L0(hmi_test_map.date)
