Schema APIs

Pointing Table

List of schemas that store pointing information Which are compatible with xradio definitions.

class ska_sdp_dataqueues.schemas.pointing_table.TimeAxis(*args: Any, **kwargs: Any)

Data model of time axis

data: Data[Time, float]: Time data

units: Attr[str] | None = 's': Time unit

long_name: Attr[str] | None = 'Observation Time': Full name of time axis

type: Attr[str] | None = 'time': Type of time

scale: Attr[str] | None = 'tai': Astropy time scale

format: Attr[str] | None = 'unix': Astropy time format

class ska_sdp_dataqueues.schemas.pointing_table.AntennaAxis(*args: Any, **kwargs: Any)

Antenna id of an antenna.

data: Data[AntennaId, int]: Antenna data

long_name: Attr[str] | None = 'Antenna ID': Full antenna name

type: Attr[str] | None = 'antenna': Antenna type

class ska_sdp_dataqueues.schemas.pointing_table.FrequencyAxis(*args: Any, **kwargs: Any)

Frequency axis

data: Data[Frequency, float]: Frequency data

units: Attr[str] | None = 'Hz': Frequency unit

long_name: Attr[str] | None = 'Frequency': Full name of frequency axis

type: Attr[str] | None = 'spectral_coord': Frequency type

frame: Attr[str] | None = 'icrs': Frequency frame

class ska_sdp_dataqueues.schemas.pointing_table.ReceptorAxis(*args: Any, **kwargs: Any)

Possible correlations that can be formed from polarised receptors.

data: Data[Receptor, str]: Receptor data

long_name: Attr[str] | None = 'Receptor Frames': Full name of receptor axis

type: Attr[str] | None = 'receptor': Receptor type

class ska_sdp_dataqueues.schemas.pointing_table.AngleAxis(*args: Any, **kwargs: Any)

Angle axis

data: Data[Angle, float]: Angle data

units: Attr[str] | None = 'rad': Angle unit

frame: Attr[str] | None = 'azel': Angle refernce frame

long_name: Attr[str] | None = '2D Angles': Full name of angle axis

type: Attr[str] | None = 'angle': Angle axis type

class ska_sdp_dataqueues.schemas.pointing_table.ConfigDict(antenna: xradio.schema.typing.Coordof.<class 'ska_sdp_dataqueues.schemas.pointing_table.AntennaAxis'>, name: xradio.schema.typing.Attr.<class 'str'> = 'MID', location: xradio.schema.typing.Attr.<class 'astropy.coordinates.earth.EarthLocation'> | None = None, receptor_frame: xradio.schema.typing.Attr.<class 'str'> = 'linear', frame: xradio.schema.typing.Attr.<class 'str'> = 'local', names: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) | None = None, diameter: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'float'>) | None = None, mount: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) | None = None, vp_type: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) | None = None, stations: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) | None = None, xyz: xradio.schema.typing.Data.(tuple[typing.Literal['antenna'], 3], <class 'float'>) | None = None, offset: xradio.schema.typing.Data.(tuple[typing.Literal['antenna'], 3], <class 'float'>) | None = None)

Telescope configuration

antenna: xradio.schema.typing.Coordof.<class 'ska_sdp_dataqueues.schemas.pointing_table.AntennaAxis'>: Antenna Axis

name: xradio.schema.typing.Attr.<class 'str'> = 'MID': Name of configuration e.g. ‘LOWR3’

location: xradio.schema.typing.Attr.<class 'astropy.coordinates.earth.EarthLocation'> = None: Location of array as an astropy EarthLocation

receptor_frame: xradio.schema.typing.Attr.<class 'str'> = 'linear': Receptor frame

frame: xradio.schema.typing.Attr.<class 'str'> = 'local': Reference frame of locations

names: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) = None: Names of each dish/station

diameter: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'float'>) = None: Diameters of dishes/stations (m)

mount: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) = None: Mount types of dishes/stations e.g. ‘altaz’ | ‘xy’ | ‘equatorial’

vp_type: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) = None: Type of voltage pattern (string)

stations: xradio.schema.typing.Data.(tuple[typing.Literal['antenna']], <class 'str'>) = None: Identifiers of the dishes/stations

xyz: xradio.schema.typing.Data.(tuple[typing.Literal['antenna'], 3], <class 'float'>) = None: Geocentric coordinates of dishes/stations

offset: xradio.schema.typing.Data.(tuple[typing.Literal['antenna'], 3], <class 'float'>) = None: Axis offset (m)

class ska_sdp_dataqueues.schemas.pointing_table.PointingTable(*args: Any, **kwargs: Any)

Data class for pointing information

time: Coordof[TimeAxis]: Time Axis

antenna: Coordof[AntennaAxis]: Antenna Axis

frequency: Coordof[FrequencyAxis]: Frequency Axis

receptor: Coordof[ReceptorAxis]: Receptor Axis

angle: Coordof[AngleAxis]: Angle Axis

pointing: Data[tuple[Time, AntennaId, Frequency, Receptor, Angle], float]: Pointing data (rad)

weight: Data[tuple[Time, AntennaId, Frequency, Receptor, Angle], float]: Weight data (rad)

residual: Data[tuple[Time, Frequency, Receptor, Angle], float]: Residual data (rad)

interval: Data[tuple[Time], float]: Interval of validity

datetime: Data[tuple[Time], float]: Date time of each data point

data_model: Attr[str] = 'PointingTable': Data model

receptor_frame: Attr[ReceptorFrame]: Receptor frame

pointing_frame: Attr[str] = 'local': Pointing frame e.g. azel, xel-el

pointingcentre: Attr[SkyCoord] = None: Centre of pointing in SkyCoord format

configuration: Attr[ConfigDict] = None: Telescope configuration

nominal: None | Data[tuple[Time, AntennaId, Frequency, Receptor, Angle], float] = None: Nominal data

expected_width: None | Data[tuple[Time, AntennaId, Frequency, Receptor, Angle], float] = None: Expected beam width (rad)

fitted_width: None | Data[tuple[Time, AntennaId, Frequency, Receptor, Angle], float] = None: Fitted beam width (rad)

fitted_width_std: None | Data[tuple[Time, AntennaId, Frequency, Receptor, Angle], float] = None: Fitted beam width uncertainty (rad)

fitted_height: None | Data[tuple[Time, AntennaId, Frequency, Receptor], float] = None: Fitted Gaussian height

fitted_height_std: None | Data[tuple[Time, AntennaId, Frequency, Receptor], float] = None: Fitted height uncertainty

band_type: Attr[str] | None = None: Observing band string

scan_type: Attr[str] | None = None: ype of scan string (eg., 5point)

track_duration: Attr[float] | None = None: Track duration (sec)

discrete_offset: Attr[np.ndarray] | None = None: Input discrete pointing relative to target (degrees)

commanded_pointing: Attr[np.ndarray] | None = None: Commanded pointings (e.g., AzEl, does not have to match pointing_frame) for each antenna at the spatial centre of the pointing observation

Pointing data - Structured numpy array

Schema for a numpy structured array which specifically stores pointing data as published by the pointing offset calibration pipeline.

class ska_sdp_dataqueues.schemas.numpy_structured_pointing.PointingNumpyArray(antenna_name: dtype('<U8'), last_scan_index: dtype('float64'), xel_offset: dtype('float64'), xel_offset_std: dtype('float64'), el_offset: dtype('float64'), el_offset_std: dtype('float64'), expected_width_h: dtype('float64'), expected_width_v: dtype('float64'), fitted_width_h: dtype('float64'), fitted_width_h_std: dtype('float64'), fitted_width_v: dtype('float64'), fitted_width_v_std: dtype('float64'), fitted_height: dtype('float64'), fitted_height_std: dtype('float64'))

Schema for structured numpy array containing pointing data produced by the Pointing Offset Calibration Pipeline.

https://developer.skao.int/projects/ska-sdp-wflow-pointing-offset/en/latest/

antenna_name: dtype('<U8'): Name of the antenna (e.g. SKA001).

last_scan_index: dtype('float64'): ID of the last scan in the series of scans used for this pointing calibration.

xel_offset: dtype('float64'): Cross-elevation offset in degrees.

xel_offset_std: dtype('float64'): Standard deviation of cross-elevation offset.

el_offset: dtype('float64'): Elevation offset in degrees.

el_offset_std: dtype('float64'): Standard deviation of elevation offset.

expected_width_h: dtype('float64'): Expected beam width in horizontal co-polarisation.

expected_width_v: dtype('float64'): Expected beam width in vertical co-polarisation.

fitted_width_h: dtype('float64'): Fitted beam width in horizontal co-polarisation.

fitted_width_h_std: dtype('float64'): Standard deviation of fitted beam in horizontal co-polarisation.

fitted_width_v: dtype('float64'): Fitted bem width in vertical co-polarisation.

fitted_width_v_std: dtype('float64'): Standard deviation of fitted beam in vertical co-polarisation.

fitted_height: dtype('float64'): Fitted Gaussian height in arbitrary units.

fitted_height_std: dtype('float64'): Standard deviation of fitted Gaussian height in arbitrary units.

to_numpy(): Convert dataclass data to structured numpy array.

Signal Display Metrics

Signal Display Data Structures.

These Data Structures are primarily used in:

And used to transmit the metric data from the Visibility Receive processor to the Signal Display API.

enum ska_sdp_dataqueues.schemas.signal_display_metrics.MetricDataTypes(value)

The current metrics types to be used as a key in MetricPayload

Member Type:: str

Valid values are as follows:

AMPLITUDE: str = <MetricDataTypes.AMPLITUDE: 'amplitude'>

AVERAGED_AMPLITUDE: str = <MetricDataTypes.AVERAGED_AMPLITUDE: 'averagedamplitude'>

PHASE: str = <MetricDataTypes.PHASE: 'phase'>

LAG_PLOT: str = <MetricDataTypes.LAG_PLOT: 'lagplot'>

SPECTRUM: str = <MetricDataTypes.SPECTRUM: 'spectrum'>

BAND_AVERAGED_X_CORR: str = <MetricDataTypes.BAND_AVERAGED_X_CORR: 'bandaveragedxcorr'>

UV_COVERAGE: str = <MetricDataTypes.UV_COVERAGE: 'uvcoverage'>

AMPLITUDE_AND_PHASE_VARIANCE: str = <MetricDataTypes.AMPLITUDE_AND_PHASE_VARIANCE: 'amplitudeandphasevariance'>

class ska_sdp_dataqueues.schemas.signal_display_metrics.SpectralWindow(freq_min: float = <factory>, freq_max: float = <factory>, count: int = <factory>, channels_id: int = <factory>, spectral_window_id: int | str = <factory>, start: int = <factory>, stride: int = <factory>): Layout of the Spectral Window

class ska_sdp_dataqueues.schemas.signal_display_metrics.DataPayload(baseline: str = <factory>, polarisation: str = <factory>, data: list[float] | float = <factory>): The payload used for most metric types

class ska_sdp_dataqueues.schemas.signal_display_metrics.DataAndComponentPayload(baseline: str = <factory>, polarisation: str = <factory>, data: list[float] = <factory>, component: list[float] = <factory>)

The payload used for sending two arrays of numbers.

For example, this is useful for the amplitudes + real components, or phases + imaginary components of visibilities. Additionally, it is used for sending scaled axis information along with the lag plot data.

class ska_sdp_dataqueues.schemas.signal_display_metrics.SpectrumPayload(polarisation: str = <factory>, power: list[float] = <factory>, angle: list[float] = <factory>): The payload used for the Spectrum graphs

class ska_sdp_dataqueues.schemas.signal_display_metrics.VariancePayload(amplitude_variance: list[float] = <factory>, phase_variance: list[float] = <factory>, distance: list[float] = <factory>): The common components of the variance payload

class ska_sdp_dataqueues.schemas.signal_display_metrics.CombinedVariancePayload(meters: ~ska_sdp_dataqueues.schemas.signal_display_metrics.VariancePayload = <factory>, wavelength: ~ska_sdp_dataqueues.schemas.signal_display_metrics.VariancePayload = <factory>, polarisation: str = <factory>): The payload used for the phase/amplitude variance vs uv distance (in meters or wavelengths).

class ska_sdp_dataqueues.schemas.signal_display_metrics.UVCoveragePayload(baseline: str = <factory>, polarisation: str = <factory>, weight: float = <factory>, u: float = <factory>, v: float = <factory>, w: float = <factory>): The payload used for the UV coverage and weight distribution plots.

class ska_sdp_dataqueues.schemas.signal_display_metrics.MetricPayload(data_type: ~ska_sdp_dataqueues.schemas.signal_display_metrics.MetricDataTypes = <factory>, processing_block_id: str = <factory>, beam_id: str = <factory>, spectral_window: ~ska_sdp_dataqueues.schemas.signal_display_metrics.SpectralWindow = <factory>, timestamp: str = <factory>, data: list[~ska_sdp_dataqueues.schemas.signal_display_metrics.DataPayload | ~ska_sdp_dataqueues.schemas.signal_display_metrics.DataAndComponentPayload | ~ska_sdp_dataqueues.schemas.signal_display_metrics.SpectrumPayload | ~ska_sdp_dataqueues.schemas.signal_display_metrics.UVCoveragePayload | ~ska_sdp_dataqueues.schemas.signal_display_metrics.CombinedVariancePayload] = <factory>): The shared metric payload all metrics should use.

ska_sdp_dataqueues.schemas.signal_display_metrics.metrics_from_dict(data: dict) → MetricPayload: Convert a Metrics Dict back to a Metric Object.

class ska_sdp_dataqueues.schemas.signal_display_metrics.VisReceiveStatistics(time: float = <factory>, type: str = 'visibility_receive', state: str = <factory>, processing_block_id: str = <factory>, execution_block_id: str = <factory>, subarray_id: str = <factory>, scan_id: int = <factory>, payloads_received: int = <factory>, time_slices: int = <factory>, time_since_last_payload: float = <factory>): The Vis Receive payload statistics.

class ska_sdp_dataqueues.schemas.signal_display_metrics.Spead2Stream(id: int = <factory>, heaps: int = <factory>, blocked: int = <factory>, incomplete_heaps: int = <factory>): The stats per stream in the Spead2 Receiver.

class ska_sdp_dataqueues.schemas.signal_display_metrics.Spead2Stats(type: str = 'receive_stats', time: float = <factory>, scan_id: int = <factory>, state: str = <factory>, total_megabytes: float = <factory>, num_heaps: int = <factory>, num_incomplete: int = <factory>, duration: float = <factory>, streams: list[~ska_sdp_dataqueues.schemas.signal_display_metrics.Spead2Stream] = <factory>): These are the stats that are sent by the Spead2 Receiver.

ska_sdp_dataqueues.schemas.signal_display_metrics.stats_from_dict(data: dict) → VisReceiveStatistics | Spead2Stats: Decode a stats packet based on the type parameter.