def _create_subarrays(self, subarray_defs):
"""
Create subarrays, setting default subarray properties
for this dataset to the first subarray.
Parameters
----------
subarray_defs : list of dicts
List of subarray definition dictionaries
{ 'antenna' : list, 'corr_products' : list}
"""
subarrays = []
for subarray_def in subarray_defs:
try:
ants = subarray_def['antenna']
except KeyError as e:
raise KeyError("Subarray definition '%s' "
"missing '%s'" % (subarray_def, str(e)))
ants = [
a if isinstance(a, katpoint.Antenna) else katpoint.Antenna(a)
for a in ants
]
try:
corr_products = subarray_def['corr_products']
except KeyError:
# Generate correlation products for all antenna pairs
# including auto-correlations
corr_products = np.array([(a1.name + c1, a2.name + c2)
for i, a1 in enumerate(ants)
for a2 in ants[i:]
for c1 in ('h', 'v')
for c2 in ('h', 'v')])
subarrays.append(Subarray(ants, corr_products))
try:
subarray = subarrays[0]
except IndexError:
raise ValueError("No subarrays were defined in '%s'" %
subarray_defs)
self.subarrays = subarrays
self.subarray = 0
self.inputs = subarray.inputs
self.ants = subarray.ants
self.corr_products = subarray.corr_products
subarray_catdata = CategoricalData(self.subarrays, [0, self._ndumps])
subarray_index_catdata = CategoricalData([self.subarray],
[0, self._ndumps])
self.sensor['Observation/subarray'] = subarray_catdata
self.sensor['Observation/subarray_index'] = subarray_index_catdata
def test_setitem_categorical(self):
data = CategoricalData(['x', 'y', 'x'], [0, 2, 4, 8])
self.cache['dog'] = data
ans = self.cache.get('dog')
assert_equal(data.unique_values, ans.unique_values)
np.testing.assert_array_equal(data.events, ans.events)
np.testing.assert_array_equal(data.indices, ans.indices)
def _create_antenna_sensors(self, antenna):
"""
Create antenna sensors.
Parameters
----------
antenna : list of :class:`katpoint.Antenna`
Antenna objects
"""
for ant in antenna:
ant_catdata = CategoricalData([ant], [0, self._ndumps])
self.sensor['Antennas/%s/antenna' % (ant.name, )] = ant_catdata
# Extract array reference from first antenna (first 5 fields of description)
array_ant_fields = ['array'] + antenna[0].description.split(',')[1:5]
array_ant = katpoint.Antenna(','.join(array_ant_fields))
self.sensor['Antennas/array/antenna'] = CategoricalData(
[array_ant], [0, self._ndumps])
def _create_spectral_windows(self, spw_defs):
"""
Create spectral windows, setting the default spectral windows
for this dataset to the first spectral window.
Parameters
----------
spw_defs : list of dictionaries
List of dictionaries defining a spectral window
"""
spws = []
if not isinstance(spw_defs, (tuple, list)):
spw_defs = [spw_defs]
required = set(['centre_freq', 'channel_width', 'num_chans'])
for spw_def in spw_defs:
# Sanity check bare minimum is present
if not required.issubset(spw_def.keys()):
raise KeyError("Spectral Window definition '%s' "
"missing '%s'" % (spw_def, required))
spws.append(SpectralWindow(**spw_def))
try:
spw = spws[0]
except IndexError:
raise ValueError("No Spectral Windows were defined")
self.spectral_windows = spws
self.spw = 0
self.channel_width = spw.channel_width
self.freqs = self.channel_freqs = spw.channel_freqs
self.channels = np.arange(spw.num_chans)
spw_catdata = CategoricalData(self.spectral_windows, [0, self._ndumps])
spw_index_catdata = CategoricalData([self.spw], [0, self._ndumps])
self.sensor['Observation/spw'] = spw_catdata
self.sensor['Observation/spw_index'] = spw_index_catdata
def gain_corrections(pol, ant, multi_channel=False, targets=False, fluxes=False):
"""Figure out N_DUMPS gain corrections given `pol` and `ant` indices."""
dumps = np.arange(N_DUMPS)
events = np.array(GAIN_EVENTS)
gains = create_gain(pol, ant, multi_channel, targets, fluxes)
gains = np.atleast_2d(gains.T)
targets = TARGET_SENSOR if targets else CategoricalData([0], [0, len(dumps)])
smooth_gains = np.full((N_DUMPS, gains.shape[0]), INVALID_GAIN, dtype=gains.dtype)
for chan, gains_per_chan in enumerate(gains):
for target in set(targets):
on_target = (targets == target)
valid = np.isfinite(gains_per_chan) & on_target[events]
smooth_gains[on_target, chan] = INVALID_GAIN if not valid.any() else \
complex_interp(dumps[on_target], events[valid], gains_per_chan[valid])
return np.reciprocal(smooth_gains)
def constant_sensor(value):
return CategoricalData([value], [0, num_dumps])
def _create_scans(self, ref_ant, dumps_def):
"""
Setup reference antenna, as well as scans
associated with it
Parameters
----------
ref_ant : :class:`katpoint.Antenna`
Reference antenna
dump_defs : list of tuples
List of (event, number of dumps, target) tuples
"""
self.ref_ant = ref_ant
def _generate_ref_ant_compound_scans():
"""
Divide dumps into periods of slewing and tracking at a target,
yielding (dump_index, 'slew'/'track', target).
"""
dump_index = 0
for event, dumps, target in dumps_def:
yield dump_index, event, target
dump_index += dumps
# Generate compound scans for the reference antenna
ref_ant_compound_scans = _generate_ref_ant_compound_scans()
# Labels seem to only involve tracks, separate them out
label_scans = [
tup for tup in ref_ant_compound_scans if tup[1] == 'track'
]
events, values, _ = zip(*label_scans)
label = CategoricalData(values, events + (self._ndumps, ))
# Generate dump indexes (events) and 'slew'/'track' (values)
# and targets for the reference antenna
events, values, targets = zip(*(_generate_ref_ant_compound_scans()))
refant = CategoricalData(values, events + (self._ndumps, ))
# DO THIS BCOS h5datav3.py does it
refant.add_unmatched(label.events)
self.sensor['Antennas/%s/activity' % self.ref_ant.name] = refant
# Derive scan states and indices from reference antenna data
scan_index = CategoricalData(list(range(len(refant))), refant.events)
self.sensor['Observation/scan_state'] = refant
self.sensor['Observation/scan_index'] = scan_index
# DO THIS BCOS h5datav3.py does it
label.align(refant.events)
# First track event unlikely to happen at dump 0
if label.events[0] > 0:
label.add(0, '')
# Derive compound scan index from the label
compscan_index = CategoricalData(range(len(label)), label.events)
self.sensor['Observation/label'] = label
self.sensor['Observation/compscan_index'] = compscan_index
# Create categorical data for our targets
targets = CategoricalData(targets, (events + (self._ndumps, )))
# DO THIS BCOS h5datav3.py does it
targets.align(refant.events)
target_index = CategoricalData(targets.indices, targets.events)
self.sensor['Observation/target'] = targets
self.sensor['Observation/target_index'] = target_index