def in_interval(self, start=None, end=None):
"""
Return part of spectrogram that lies in [start, end).
Parameters
----------
start : None or `~datetime.datetime` or `~sunpy.time.parse_time` compatible string or time string
Start time of the part of the spectrogram that is returned. If the
measurement only spans over one day, a colon separated string
representing the time can be passed.
end : None or `~datetime.datetime` or `~sunpy.time.parse_time` compatible string or time string
See start.
"""
if start is not None:
try:
if SUNPY_LT_1:
start = parse_time(start)
else:
start = parse_time(start).datetime
except ValueError:
# XXX: We could do better than that.
if get_day(self.start) != get_day(self.end):
raise TypeError(
"Time ambiguous because data spans over more than one day"
)
start = datetime.datetime(
self.start.year, self.start.month, self.start.day,
*list(map(int, start.split(":")))
)
start = self.time_to_x(start)
if end is not None:
try:
if SUNPY_LT_1:
end = parse_time(end)
else:
end = parse_time(end).datetime
except ValueError:
if get_day(self.start) != get_day(self.end):
raise TypeError(
"Time ambiguous because data spans over more than one day"
)
end = datetime.datetime(
self.start.year, self.start.month, self.start.day,
*list(map(int, end.split(":")))
)
end = self.time_to_x(end)
if start:
start = int(start)
if end:
end = int(end)
return self[:, start:end]
def __init__(self, data, time_axis, freq_axis, start, end, t_init=None,
t_label="Time", f_label="Frequency", content="",
instruments=None):
# Because of how object creation works, there is no avoiding
# unused arguments in this case.
self.data = data
if t_init is None:
diff = start - get_day(start)
t_init = diff.seconds
if instruments is None:
instruments = set()
self.start = start
self.end = end
self.t_label = t_label
self.f_label = f_label
self.t_init = t_init
self.time_axis = time_axis
self.freq_axis = freq_axis
self.content = content
self.instruments = instruments
def read(cls, filename, **kwargs):
"""
Read in FITS file and return a new SWavesSpectrogram.
"""
fl = fits.open(filename, **kwargs)
data = fl[0].data
freq_axis = fl[1].data.sfreq
tdata = fl[2].data
mjd = tdata.mjd
sec = tdata.time / 1000.
start = Time(mjd[0] + sec[0] / 86400., format='mjd').datetime
end = Time(mjd[-1] + sec[-1] / 86400., format='mjd').datetime
time_axis = sec - sec[0]
header = fl[0].header
t_delt = 1.0
t_init = (start - get_day(start)).seconds
content = 'EOVSA'
t_label = 'Time [UT]'
f_label = 'Frequency [GHz]'
#reverse the frequency axis
freq_axis = freq_axis[::-1]
data = data[::-1, :]
return cls(data, time_axis, freq_axis, start, end, t_init, t_delt,
t_label, f_label, content)
def test_get_day():
end_of_day = datetime(year=2017,
month=1,
day=1,
hour=23,
minute=59,
second=59,
microsecond=999)
begining_of_day = get_day(end_of_day)
assert begining_of_day.year == 2017
assert begining_of_day.month == 1
assert begining_of_day.day == 1
assert begining_of_day.hour == 0
assert begining_of_day.minute == 0
assert begining_of_day.second == 0
assert begining_of_day.microsecond == 0
def read(cls, filename, **kwargs):
"""
Read in FITS file and return a new SWavesSpectrogram.
"""
data = np.genfromtxt(filename, skip_header=2)
time_axis = data[:, 0] * 60.
data = data[:, 1:].transpose()
header = np.genfromtxt(filename, skip_footer=time_axis.size)
freq_axis = header[0, :]
bg = header[1, :]
start = cls.swavesfile_to_date(filename)
end = start + datetime.timedelta(seconds=time_axis[-1])
t_delt = 60.
t_init = (start - get_day(start)).seconds
content = ''
t_label = 'Time [UT]'
f_label = 'Frequency [KHz]'
freq_axis = freq_axis[::-1]
data = data[::-1, :]
return cls(data, time_axis, freq_axis, start, end, t_init, t_delt,
t_label, f_label, content, bg)
def plot(self, figure=None, overlays=[], colorbar=True, vmin=None,
vmax=None, linear=True, showz=True, yres=DEFAULT_YRES,
max_dist=None, **matplotlib_args):
"""
Plot spectrogram onto figure.
Parameters
----------
figure : `~matplotlib.Figure`
Figure to plot the spectrogram on. If None, new Figure is created.
overlays : list
List of overlays (functions that receive figure and axes and return
new ones) to be applied after drawing.
colorbar : bool
Flag that determines whether or not to draw a colorbar. If existing
figure is passed, it is attempted to overdraw old colorbar.
vmin : float
Clip intensities lower than vmin before drawing.
vmax : float
Clip intensities higher than vmax before drawing.
linear : bool
If set to True, "stretch" image to make frequency axis linear.
showz : bool
If set to True, the value of the pixel that is hovered with the
mouse is shown in the bottom right corner.
yres : int or None
To be used in combination with linear=True. If None, sample the
image with half the minimum frequency delta. Else, sample the
image to be at most yres pixels in vertical dimension. Defaults
to 1080 because that's a common screen size.
max_dist : float or None
If not None, mask elements that are further than max_dist away
from actual data points (ie, frequencies that actually have data
from the receiver and are not just nearest-neighbour interpolated).
"""
# [] as default argument is okay here because it is only read.
# pylint: disable=W0102,R0914
if linear:
delt = yres
if delt is not None:
delt = max(
(self.freq_axis[0] - self.freq_axis[-1]) / (yres - 1),
_min_delt(self.freq_axis) / 2.
)
delt = float(delt)
data = _LinearView(self.clip_values(vmin, vmax), delt)
freqs = np.arange(
self.freq_axis[0], self.freq_axis[-1], -data.delt
)
else:
data = np.array(self.clip_values(vmin, vmax))
freqs = self.freq_axis
figure = plt.gcf()
if figure.axes:
axes = figure.axes[0]
else:
axes = figure.add_subplot(111)
params = {
'origin': 'lower',
'aspect': 'auto',
}
params.update(matplotlib_args)
if linear and max_dist is not None:
toplot = ma.masked_array(data, mask=data.make_mask(max_dist))
else:
toplot = data
im = axes.imshow(toplot, **params)
xa = axes.get_xaxis()
ya = axes.get_yaxis()
xa.set_major_formatter(
FuncFormatter(self.time_formatter)
)
if linear:
# Start with a number that is divisible by 5.
init = (self.freq_axis[0] % 5) / data.delt
nticks = 15.
# Calculate MHz difference between major ticks.
dist = (self.freq_axis[0] - self.freq_axis[-1]) / nticks
# Round to next multiple of 10, at least ten.
dist = max(round(dist, -1), 10)
# One pixel in image space is data.delt MHz, thus we can convert
# our distance between the major ticks into image space by dividing
# it by data.delt.
ya.set_major_locator(
IndexLocator(
dist / data.delt, init
)
)
ya.set_minor_locator(
IndexLocator(
dist / data.delt / 10, init
)
)
def freq_fmt(x, pos):
# This is necessary because matplotlib somehow tries to get
# the mid-point of the row, which we do not need here.
x = x + 0.5
return self.format_freq(self.freq_axis[0] - x * data.delt)
else:
freq_fmt = _list_formatter(freqs, self.format_freq)
ya.set_major_locator(MaxNLocator(integer=True, steps=[1, 5, 10]))
ya.set_major_formatter(
FuncFormatter(freq_fmt)
)
axes.set_xlabel(self.t_label)
axes.set_ylabel(self.f_label)
# figure.suptitle(self.content)
figure.suptitle(
' '.join([
get_day(self.start).strftime("%d %b %Y"),
'Radio flux density',
'(' + ', '.join(self.instruments) + ')',
])
)
for tl in xa.get_ticklabels():
tl.set_fontsize(10)
tl.set_rotation(30)
figure.add_axes(axes)
figure.subplots_adjust(bottom=0.2)
figure.subplots_adjust(left=0.2)
if showz:
axes.format_coord = self._mk_format_coord(
data, figure.gca().format_coord)
if colorbar:
if len(figure.axes) > 1:
Colorbar(figure.axes[1], im).set_label("Intensity")
else:
figure.colorbar(im).set_label("Intensity")
for overlay in overlays:
figure, axes = overlay(figure, axes)
for ax in figure.axes:
ax.autoscale()
if isinstance(figure, SpectroFigure):
figure._init(self, freqs)
return axes
def join_many(cls, specs, mk_arr=None, nonlinear=False,
maxgap=0, fill=JOIN_REPEAT):
"""
Produce new Spectrogram that contains spectrograms joined together in
time.
Parameters
----------
specs : list
List of spectrograms to join together in time.
nonlinear : bool
If True, leave out gaps between spectrograms. Else, fill them with
the value specified in fill.
maxgap : float, int or None
Largest gap to allow in second. If None, allow gap of arbitrary
size.
fill : float or int
Value to fill missing values (assuming nonlinear=False) with.
Can be LinearTimeSpectrogram.JOIN_REPEAT to repeat the values for
the time just before the gap.
mk_array: function
Function that is called to create the resulting array. Can be set
to LinearTimeSpectrogram.memap(filename) to create a memory mapped
result array.
"""
# XXX: Only load header and load contents of files
# on demand.
mask = None
if mk_arr is None:
mk_arr = cls.make_array
specs = sorted(specs, key=lambda x: x.start)
freqs = specs[0].freq_axis
if not all(np.array_equal(freqs, sp.freq_axis) for sp in specs):
raise ValueError("Frequency channels do not match.")
# Smallest time-delta becomes the common time-delta.
min_delt = min(sp.t_delt for sp in specs)
dtype_ = max(sp.dtype for sp in specs)
specs = [sp.resample_time(min_delt) for sp in specs]
size = sum(sp.shape[1] for sp in specs)
data = specs[0]
start_day = data.start
xs = []
last = data
for elem in specs[1:]:
e_init = (
SECONDS_PER_DAY * (
get_day(elem.start) - get_day(start_day)
).days + elem.t_init
)
x = int((e_init - last.t_init) / min_delt)
xs.append(x)
diff = last.shape[1] - x
if maxgap is not None and -diff > maxgap / min_delt:
raise ValueError("Too large gap.")
# If we leave out undefined values, we do not want to
# add values here if x > t_res.
if nonlinear:
size -= max(0, diff)
else:
size -= diff
last = elem
# The non existing element after the last one starts after
# the last one. Needed to keep implementation below sane.
xs.append(specs[-1].shape[1])
# We do that here so the user can pass a memory mapped
# array if they'd like to.
arr = mk_arr((data.shape[0], size), dtype_)
time_axis = np.zeros((size,))
sx = 0
# Amount of pixels left out due to non-linearity. Needs to be
# considered for correct time axes.
sd = 0
for x, elem in zip(xs, specs):
diff = x - elem.shape[1]
e_time_axis = elem.time_axis
elem = elem.data
if x > elem.shape[1]:
if nonlinear:
x = elem.shape[1]
else:
# If we want to stay linear, fill up the missing
# pixels with placeholder zeros.
filler = np.zeros((data.shape[0], diff))
if fill is cls.JOIN_REPEAT:
filler[:, :] = elem[:, -1, np.newaxis]
else:
filler[:] = fill
minimum = e_time_axis[-1]
e_time_axis = np.concatenate([
e_time_axis,
np.linspace(
minimum + min_delt,
minimum + diff * min_delt,
diff
)
])
elem = np.concatenate([elem, filler], 1)
arr[:, sx:sx + x] = elem[:, :x]
if diff > 0:
if mask is None:
mask = np.zeros((data.shape[0], size), dtype=np.uint8)
mask[:, sx + x - diff:sx + x] = 1
time_axis[sx:sx + x] = e_time_axis[:x] + data.t_delt * (sx + sd)
if nonlinear:
sd += max(0, diff)
sx += x
params = {
'time_axis': time_axis,
'freq_axis': data.freq_axis,
'start': data.start,
'end': specs[-1].end,
't_delt': data.t_delt,
't_init': data.t_init,
't_label': data.t_label,
'f_label': data.f_label,
'content': data.content,
'instruments': _union(spec.instruments for spec in specs),
}
if mask is not None:
arr = ma.array(arr, mask=mask)
if nonlinear:
del params['t_delt']
return Spectrogram(arr, **params)
return common_base(specs)(arr, **params)