pipeline.domain package

Submodules

pipeline.domain.antenna module

The antenna module defines the Antenna class.

class pipeline.domain.antenna.Antenna(antenna_id, name, station, position, offset, diameter)

Bases: object

Antenna is a logical representation of an antenna.

An Antenna has the following properties:

id

the numerical identifier of this antenna within the ANTENNA subtable of the measurement set

name

the (potentially empty) name of this antenna

longitude

the longitude of this antenna

latitude

the latitude of this antenna

height

the radial distance of this antenna from the Earth’s centre

diameter

the physical diameter of this antenna

direction

the J2000 position on the sky to which this antenna points

property identifier

A human-readable identifier for this Antenna.

pipeline.domain.antennaarray module

class pipeline.domain.antennaarray.AntennaArray(name, position, antennas=None)

Bases: object

add_antenna(antenna)

property baselines

property centre

property elevation

Get the array elevation as a CASA quantity.

get_antenna(id=None, name=None)

get_baseline(antenna1, antenna2)

get_offset(antenna)

Get the offset of the given antenna from the centre of the array.

property latitude

Get the array latitude as a CASA quantity.

property longitude

Get the array longitude as a CASA quantity.

property max_baseline

property median_direction

The median center direction for the array.

property min_baseline

property name

property position

class pipeline.domain.antennaarray.Baseline(antenna1, antenna2, length)

Bases: tuple

property antenna1

Alias for field number 0

property antenna2

Alias for field number 1

property length

Alias for field number 2

pipeline.domain.datadescription module

class pipeline.domain.datadescription.DataDescription(dd_id, spw, pol_id)

Bases: object

get_polarization_id(pol)

get_polarization_label(pol_id)

Get the polarization label associated with the polarization ID. This converts an integer to a string, eg. 0 -> ‘XX’.

property num_polarizations

property polarizations

pipeline.domain.datatable module

class pipeline.domain.datatable.DataTableColumnMaskList(table)

Bases: pipeline.domain.datatable.RWDataTableColumn

NoMask = array([[-1, -1]], dtype=int32)

getcell(idx)

getcol(startrow=0, nrow=- 1, rowincr=1)

Note: returned array has shape (nrow,nmask), in

contrast to (nmask,nrow) for return value of tb.getcol().

putcell(idx, val)

putcol(val, startrow=0, nrow=- 1, rowincr=1)

Note: input array should have shape (nrow,nmask), in

contrast to (nmask,nrow) for tb.putcol()

class pipeline.domain.datatable.DataTableColumnNoChange(table)

Bases: pipeline.domain.datatable.RWDataTableColumn

putcell(idx, val)

class pipeline.domain.datatable.DataTableImpl(name=None, readonly=None)

Bases: object

DataTable is an object to hold meta data of scantable on memory.

row layout: [Row, Scan, IF, Pol, Beam, Date, Time, ElapsedTime,

0, 1, 2, 3, 4, 5, 6, 7,

Exptime, RA, DEC, Az, El, nchan, Tsys, TargetName,

8, 9, 10, 11, 12, 13, 14, 15,

Statistics, Flags, PermanentFlags, SummaryFlag, Nmask, MaskList, NoChange, Ant]

16, 17, 18, 19, 20, 21, 22, 23

Statistics: DataTable[ID][16] =

[LowFreqRMS, NewRMS, OldRMS, NewRMSdiff, OldRMSdiff, ExpectedRMS, ExpectedRMS]

0, 1, 2, 3, 4, 5, 6

Flags: DataTable[ID][17] =

[LowFrRMSFlag, PostFitRMSFlag, PreFitRMSFlag, PostFitRMSdiff, PreFitRMSdiff, PostFitExpRMSFlag, PreFitExpRMSFlag]

0, 1, 2, 3, 4, 5, 6

PermanentFlags: DataTable[ID][18] =

[WeatherFlag, TsysFlag, UserFlag]

0, 1, 2

Note for Flags: 1 is valid, 0 is invalid

REFKEY = 'DIRECTION_REF'

addrows(nrow)

colnames()

property direction_ref

export_rwtable_exclusive(dirty_rows=None, cols=None)

Export “on-memory” RW table to the one on disk.

To support parallel operation, the method will acquire a lock for RW table to ensure the operation in one process doesn’t overwrite the changes made by other processes.

dirty_rows – list of row numbers that are updated. If None, everything

including unchanged rows will be flushed. Default is None.

cols – list of columns that are updated. If None, all rows will be flushed.

default is None.

exportdata(name=None, minimal=True, overwrite=False)

name – name of exported DataTable overwrite – overwrite existing DataTable

get_posdict(ant, spw, pol)

classmethod get_rotable_name(datatable_name)

classmethod get_rwtable_name(datatable_name)

get_timegap(ant, spw, pol, asrow=True, ms=None, field_id=None)

get_timetable(ant, spw, pol, ms=None, field_id=None)

getcell(name, idx)

getcellslice(name, rownr, blc, trc, incr)

getcol(name, startrow=0, nrow=- 1, rowincr=1)

getcolkeyword(columnname, keyword)

getcolslice(name, blc, trc, incr, startrow=0, nrow=- 1, rowincr=1)

getkeyword(name)

name – keyword name

haskeyword(name)

importdata(name, minimal=True, readonly=True)

name – name of DataTable to be imported

importdata2(name, minimal=True, readonly=True)

name – name of DataTable to be imported

keywordnames()

return table keyword names

property name

property nrow

property position_group_id

putcell(name, idx, val)

name – column name idx – row index val – value to be put

putcellslice(name, rownr, value, blc, trc, incr)

putcol(name, val, startrow=0, nrow=- 1, rowincr=1)

putcolslice(name, value, blc, trc, incr, startrow=0, nrow=- 1, rowincr=1)

putkeyword(name, val)

name – keyword name val – keyword value

set_timetable(ant, spw, pol, mygrp, timegrp_s, timegrp_l, ms=None, field_id=None)

sync(minimal=True)

Sync with DataTable on disk.

property time_group_id_large

property time_group_id_small

class pipeline.domain.datatable.DataTableIndexer(context)

Bases: object

DataTableIndexer is responsible for mapping between classical (serial) row indices and per-MS row indices.

property mses

per_ms_index_list(ms, index_list)

perms2serial(vis, i)

Return serial index.

vis – basename of the MS i – per MS datatable row index

serial2perms(i)

Return two indices. The former indicates a MS index while the later corresponds to the row index of the datatable for that MS.

i – serial index

class pipeline.domain.datatable.RODataTableColumn(table, name, dtype)

Bases: object

getcell(idx)

getcellslice(rownr, blc, trc, incr)

getcol(startrow=0, nrow=- 1, rowincr=1)

getcolslice(blc, trc, incr, startrow=0, nrow=- 1, rowincr=1)

putcell(idx, val)

putcellslice(rownr, value, blc, trc, incr)

putcol(val, startrow=0, nrow=- 1, rowincr=1)

putcolslice(value, blc, trc, incr, startrow=0, nrow=- 1, rowincr=1)

class pipeline.domain.datatable.RWDataTableColumn(table, name, dtype)

Bases: pipeline.domain.datatable.RODataTableColumn

putcell(idx, val)

putcellslice(rownr, value, blc, trc, incr)

putcol(val, startrow=0, nrow=- 1, rowincr=1)

putcolslice(value, blc, trc, incr, startrow=0, nrow=- 1, rowincr=1)

pipeline.domain.datatable.absolute_path(name)

pipeline.domain.datatable.construct_timegroup(rows, group_id_list, group_association_list)

pipeline.domain.datatable.create_table(table, name, desc, memtype='plain', nrow=0)

pipeline.domain.datatable.timetable_key(table_type, antenna, spw, polarization=None, ms=None, field_id=None)

pipeline.domain.field module

class pipeline.domain.field.Field(field_id, name, source_id, time, direction)

Bases: object

property clean_name

Get the field name with illegal characters replaced with underscores.

This property is used to determine whether the field name, when given as a CASA argument, should be enclosed in quotes.

property dec

property frame

property gb

property gl

property identifier

A human-readable identifier for this Field.

property latitude

property longitude

property mdirection

property name

property ra

set_source_type(source_type)

pipeline.domain.fluxmeasurement module

class pipeline.domain.fluxmeasurement.FluxMeasurement(spw_id, I, Q=FluxDensity(0, FluxDensityUnits.JANSKY), U=FluxDensity(0, FluxDensityUnits.JANSKY), V=FluxDensity(0, FluxDensityUnits.JANSKY), spix=Decimal('0.0'), uvmin=Decimal('0.0'), uvmax=Decimal('0.0'), origin=None, age=None, queried_at=None)

Bases: object

property casa_flux_density

pipeline.domain.measurementset module

class pipeline.domain.measurementset.MeasurementSet(name, session=None)

Bases: object

property antennas

property basename

property end_time

get_all_spectral_windows(task_arg='', with_channels=False)

Return the spectral windows corresponding to the given CASA-style spw argument.

get_alma_corrstring()

Get correlation string for ALMA for the science windows

get_antenna(search_term='')

get_data_description(spw=None, id=None)

get_fields(task_arg=None, field_id=None, name=None, intent=None)

Get Fields from this MeasurementSet matching the given criteria. If no criteria are given, all Fields in the MeasurementSet will be returned.

Arguments can be given as either single items of the expected type, sequences of the expected type, or in the case of name or intent, as comma separated strings. For instance, name could be ‘HOIX’, ‘HOIX,0841+708’ or (‘HOIX’,’0841+708’).

Parameters

• field_id – field ID(s) to match

• name – field name(s) to match

• intent – observing intent(s) to match

Return type

a (potentially empty) list of Field objects

get_median_integration_time(intent=None)

Get the median integration time used to get data for the given intent.

Keyword arguments: intent – The intent of the data of interest.

Returns – The median integration time used.

get_median_science_integration_time(intent=None, spw=None)

Get the median integration time for science targets used to get data for the given intent.

Keyword arguments: intent – The intent of the data of interest. spw – spw string list - ‘1,7,11,18’

Returns – The median integration time used.

get_original_intent(intent=None)

Get the original obs_modes that correspond to the given pipeline observing intents.

get_representative_source_spw(source_name=None, source_spwid=None)

get_scans(scan_id=None, scan_intent=None, field=None, spw=None)

get_spectral_window(spw_id)

get_spectral_windows(task_arg='', with_channels=False, num_channels=(), science_windows_only=True)

Return the spectral windows corresponding to the given CASA-style spw argument, filtering out windows that may not be science spectral windows (WVR windows, channel average windows etc.).

get_state(state_id=None)

get_vla_corrstring()

Get correlation string for VLA

get_vla_critfrac()

Identify bands/basebands/spws

get_vla_datadesc()

Generate VLA data description index

get_vla_field_ids()

Find field ids for VLA

get_vla_field_names()

Find field names for VLA

get_vla_field_spws(spwlist=[])

Find field spws for VLA

get_vla_max_integration_time()

Get the integration time used by the original VLA scripts

Returns – The max integration time used

get_vla_numchan()

Get number of channels for VLA

get_vla_quackingscans()

Find VLA scans for quacking. Quack! :)

get_vla_spw2band()

get_vla_tst_bpass_spw(spwlist=[])

Get VLA test bandpass spws

get_vla_tst_delay_spw(spwlist=[])

Get VLA test bandpass spws

property intents

property reference_antenna

Get the reference antenna list for this MS. The refant value is a comma-separated string.

Example: ‘DV01,DV02,DV03’

property session

property start_time

update_reference_antennas(ants_to_demote=None, ants_to_remove=None)

Update the reference antenna list by demoting and/or removing specified antennas.

If the same antenna is specified to be demoted and to be removed, it is removed.

Parameters

• ants_to_demote – list of antenna names to demote

• ants_to_remove – list of antenna names to remove

vla_minbaselineforcal()

vla_spws_for_field(field)

VLA spws for field

pipeline.domain.measures module

class pipeline.domain.measures.ArcUnits

Bases: object

ARC_MINUTE = {'html': ''', 'name': 'ARC_MINUTE', 'symbol': "'", 'units per circle': Decimal('21600')}

ARC_SECOND = {'html': '"', 'name': 'ARC_SECOND', 'symbol': '"', 'units per circle': Decimal('1296000')}

DEGREE = {'html': '°', 'name': 'DEGREE', 'symbol': 'd', 'units per circle': Decimal('360')}

HOUR = {'html': 'h', 'name': 'HOUR', 'symbol': 'h', 'units per circle': Decimal('24')}

MILLI_ARC_SECOND = {'html': 'mas', 'name': 'MILLI_ARC_SECOND', 'symbol': 'mas', 'units per circle': Decimal('1296000000')}

MINUTE = {'html': 'm', 'name': 'MINUTE', 'symbol': 'm', 'units per circle': Decimal('1440')}

PERCENT = {'html': '%', 'name': 'PERCENT', 'symbol': '%', 'units per circle': Decimal('100')}

RADIAN = {'html': 'rad', 'name': 'RADIAN', 'symbol': 'rad', 'units per circle': Decimal('6.283185307179586')}

SECOND = {'html': 's', 'name': 'SECOND', 'symbol': 's', 'units per circle': Decimal('86400')}

class pipeline.domain.measures.ComparableUnit

Bases: object

convert_to(newUnits=None)

to_units(otherUnits=None)

units

value

class pipeline.domain.measures.Distance(value=0, units={'metres': Decimal('1000'), 'name': 'KILOMETRE', 'symbol': 'km'})

Bases: pipeline.domain.measures.ComparableUnit

convert_to(newUnits={'metres': Decimal('1'), 'name': 'METRE', 'symbol': 'm'})

Converts this measure of distance to the new units.

After this method is complete this distance will have units of newUnits and its value will have been converted accordingly.

newUnits

the new units for this distance (default: m)

Returns

this distance. The reason for this return type is to allow code of this nature:

kilometers = myDistance.convert_to(DistanceUnits.KILOMETRES).value

to_units(otherUnits={'metres': Decimal('1'), 'name': 'METRE', 'symbol': 'm'})

Returns the magnitude of this distance in otherUnits.

Note that this method does not alter the state of this distance. Contrast this with convert_to(DistanceUnits).

otherUnits

the units in which to express this distance’s magnitude.

Returns

this distance’s value converted to otherUnits.

units

value

class pipeline.domain.measures.DistanceUnits

Bases: object

ANGSTROM = {'metres': Decimal('1E-10'), 'name': 'ANGSTROM', 'symbol': '\\u212B'}

ASTRONOMICAL_UNIT = {'metres': Decimal('149597870691'), 'name': 'ASTRONOMICAL_UNIT', 'symbol': 'au'}

CENTIMETRE = {'metres': Decimal('0.01'), 'name': 'CENTIMETRE', 'symbol': 'cm'}

KILOMETRE = {'metres': Decimal('1000'), 'name': 'KILOMETRE', 'symbol': 'km'}

KILOPARSEC = {'metres': Decimal('3.085677581306E+19'), 'name': 'KILOPARSEC', 'symbol': 'kpc'}

LIGHT_MINUTE = {'metres': Decimal('17987547480'), 'name': 'LIGHT_MINUTE', 'symbol': 'lm'}

LIGHT_SECOND = {'metres': Decimal('299792458'), 'name': 'LIGHT_SECOND', 'symbol': 'ls'}

LIGHT_YEAR = {'metres': Decimal('9.4607304725808E+15'), 'name': 'LIGHT_YEAR', 'symbol': 'ly'}

MEGAPARSEC = {'metres': Decimal('3.085677581306E+22'), 'name': 'MEGAPARSEC', 'symbol': 'Mpc'}

METRE = {'metres': Decimal('1'), 'name': 'METRE', 'symbol': 'm'}

MICROMETRE = {'metres': Decimal('0.000001'), 'name': 'MICROMETRE', 'symbol': '\\u00B5m'}

MILE = {'metres': Decimal('1609.347219'), 'name': 'MILE', 'symbol': 'mi'}

MILLIMETRE = {'metres': Decimal('0.001'), 'name': 'MILLIMETRE', 'symbol': 'mm'}

NANOMETRE = {'metres': Decimal('1E-9'), 'name': 'NANOMETRE', 'symbol': 'nm'}

PARSEC = {'metres': Decimal('3.085677581306E+16'), 'name': 'PARSEC', 'symbol': 'pc'}

class pipeline.domain.measures.EquatorialArc(value=0, units={'html': '°', 'name': 'DEGREE', 'symbol': 'd', 'units per circle': Decimal('360')})

Bases: pipeline.domain.measures.ComparableUnit

convert_to(newUnits={'html': '°', 'name': 'DEGREE', 'symbol': 'd', 'units per circle': Decimal('360')})

Converts this arc to the new units.

After this method is complete this arc will have units of units and its value will have been converted accordingly.

newUnits

the new units for this arc. default: degrees

Returns

this arc. The reason for this return type is to allow code of this nature:

radians = myArc.convert_to(ArcUnits.RADIAN).value;

toDms()

Returns a representation of this arc in degrees, minutes, and seconds.

Returns

An integer holding the number of degrees. An integer holding the number of arc minutes. A float holding the number of arc seconds.

Return type

a tuple of size three in this order

toHms()

Returns a representation of this arc in hours, minutes, and seconds.

Returns

An integer holding the number of hours. An integer holding the number of minutes. A float holding the number of seconds.

Return type

a tuple of size three in this order

to_units(otherUnits={'html': '°', 'name': 'DEGREE', 'symbol': 'd', 'units per circle': Decimal('360')})

Returns the magnitude of this arc in otherUnits.

Note that this method does not alter the state of this arc. Contrast this with convert_to(ArcUnits).

otherUnits

the units in which to express this arc’s magnitude (default: degrees)

Returns

this arc’s value converted to otherUnits.

units

value

class pipeline.domain.measures.FileSize(value=0, units={'bytes': Decimal('1048576'), 'name': 'MEGABYTES', 'symbol': 'Mb'})

Bases: pipeline.domain.measures.ComparableUnit

convert_to(newUnits={'bytes': Decimal('1048576'), 'name': 'MEGABYTES', 'symbol': 'Mb'})

Converts this measure of file size to the new units.

After this method is complete this file size will have units of newUnits and its value will have been converted accordingly.

newUnits

the new units for this file size.

Returns

this file size. The reason for this return type is to allow code of this nature:

gigabytes = myFileSize.convert_to(FrequencyUnits.GIGABYTES)

to_units(otherUnits={'bytes': Decimal('1073741824'), 'name': 'GIGABYTES', 'symbol': 'Gb'})

Returns the magnitude of this file size in otherUnits.

Note that this method does not alter the state of this file size. Contrast this with convert_to(FileSizeUnits).

otherUnits

the units in which to express this file size’s magnitude. If newUnits is None, it will be treated as FileSizeUnits.GIGABYTES.

Returns

this file size’s value converted to otherUnits.

units

value

class pipeline.domain.measures.FileSizeUnits

Bases: object

BYTES = {'bytes': Decimal('1'), 'name': 'BYTES', 'symbol': 'b'}

GIGABYTES = {'bytes': Decimal('1073741824'), 'name': 'GIGABYTES', 'symbol': 'Gb'}

KILOBYTES = {'bytes': Decimal('1024'), 'name': 'KILOBYTES', 'symbol': 'kb'}

MEGABYTES = {'bytes': Decimal('1048576'), 'name': 'MEGABYTES', 'symbol': 'Mb'}

TERABYTES = {'bytes': Decimal('1099511627776'), 'name': 'TERABYTES', 'symbol': 'Tb'}

class pipeline.domain.measures.FluxDensity(value=0, units={'Jy': Decimal('1'), 'name': 'JANSKY', 'symbol': 'Jy'})

Bases: pipeline.domain.measures.ComparableUnit

convert_to(newUnits={'Jy': Decimal('1'), 'name': 'JANSKY', 'symbol': 'Jy'})

Converts this measure of flux density to the new units. After this method is complete this flux density will have units of units and its value will have been converted accordingly.

newUnits

the new units for this flux density (default: Jy)

Returns

this flux density. The reason for this return type is to allow code of this nature:

janskies = myFluxDensity.convert_to(FluxDensityUnits.JANSKY)

to_units(otherUnits={'Jy': Decimal('1'), 'name': 'JANSKY', 'symbol': 'Jy'})

Returns the magnitude of this flux density in otherUnits.

Note that this method does not alter the state of this flux density. Contrast this with convert_to(FluxDensityUnits).

otherUnits

the units in which to express this flux density’s magnitude.

Returns

this flux density’s value converted to otherUnits.

units

value

class pipeline.domain.measures.FluxDensityUnits

Bases: object

ATTOJANSKY = {'Jy': Decimal('1E-18'), 'name': 'ATTOJANSKY', 'symbol': 'aJy'}

CENTIJANSKY = {'Jy': Decimal('0.01'), 'name': 'CENTIJANSKY', 'symbol': 'cJy'}

DECAJANSKY = {'Jy': Decimal('10'), 'name': 'DECAJANSKY', 'symbol': 'daJy'}

DECIJANSKY = {'Jy': Decimal('0.1'), 'name': 'DECIJANSKY', 'symbol': 'dJy'}

ETAJANSKY = {'Jy': Decimal('1E+18'), 'name': 'ETAJANSKY', 'symbol': 'EJy'}

FEMTOJANSKY = {'Jy': Decimal('1E-15'), 'name': 'FEMTOJANSKY', 'symbol': 'fJy'}

GIGAJANSKY = {'Jy': Decimal('1E+9'), 'name': 'GIGAJANSKY', 'symbol': 'GJy'}

HECTOJANSKY = {'Jy': Decimal('100'), 'name': 'HECTOJANSKY', 'symbol': 'hJy'}

JANSKY = {'Jy': Decimal('1'), 'name': 'JANSKY', 'symbol': 'Jy'}

KILOJANSKY = {'Jy': Decimal('1000'), 'name': 'KILOJANSKY', 'symbol': 'kJy'}

MEGAJANSKY = {'Jy': Decimal('1E+6'), 'name': 'MEGAJANSKY', 'symbol': 'MJy'}

MICROJANSKY = {'Jy': Decimal('0.000001'), 'name': 'MICROJANSKY', 'symbol': '\\u03BCJy'}

MILLIJANSKY = {'Jy': Decimal('0.001'), 'name': 'MILLIJANSKY', 'symbol': 'mJy'}

NANOJANSKY = {'Jy': Decimal('1E-9'), 'name': 'NANOJANSKY', 'symbol': 'nJy'}

PETAJANSKY = {'Jy': Decimal('1E+15'), 'name': 'PETAJANSKY', 'symbol': 'PJy'}

PICOJANSKY = {'Jy': Decimal('1E-12'), 'name': 'PICOJANSKY', 'symbol': 'pJy'}

TERAJANSKY = {'Jy': Decimal('1E+12'), 'name': 'TERAJANSKY', 'symbol': 'TJy'}

YOCTOJANSKY = {'Jy': Decimal('1E-24'), 'name': 'YOCTOJANSKY', 'symbol': 'yJy'}

YOTTAJANSKY = {'Jy': Decimal('1E+24'), 'name': 'YOTTAJANSKY', 'symbol': 'YJy'}

ZEPTOJANSKY = {'Jy': Decimal('1E-21'), 'name': 'ZEPTOJANSKY', 'symbol': 'zJy'}

ZETTAJANSKY = {'Jy': Decimal('1E+21'), 'name': 'ZETTAJANSKY', 'symbol': 'ZJy'}

class pipeline.domain.measures.Frequency(value=0, units={'hz': Decimal('1E+9'), 'name': 'GIGAHERTZ', 'symbol': 'GHz'})

Bases: pipeline.domain.measures.ComparableUnit

convert_to(newUnits={'hz': Decimal('1E+9'), 'name': 'GIGAHERTZ', 'symbol': 'GHz'})

Converts this measure of frequency to the new units.

After this method is complete this frequency will have units of newUnits and its value will have been converted accordingly.

newUnits

the new units for this frequency.

Returns

this frequency. The reason for this return type is to allow code of this nature:

gigahertz = myFrequency.convert_to(FrequencyUnits.GIGAHERTZ)

str_to_precision(precision)

Return the string representation of this Frequency to a fixed number of decimal places.

Parameters

precision –

Returns

to_units(otherUnits={'hz': Decimal('1E+9'), 'name': 'GIGAHERTZ', 'symbol': 'GHz'})

Returns the magnitude of this frequency in otherUnits.

Note that this method does not alter the state of this frequency. Contrast this with convert_to(FrequencyUnits).

otherUnits

the units in which to express this frequency’s magnitude. If newUnits is None, it will be treated as FrequencyUnits.GIGAHERTZ.

Returns

this frequency’s value converted to otherUnits.

units

value

class pipeline.domain.measures.FrequencyRange(frequency1=None, frequency2=None)

Bases: object

contains(frequency=None)

Returns true if this range contains frequency.

The frequency argument be a frequency or a frequency range. If the argument given is a Frequency range, then FrequencyRange A is said to contain range B if A’s low frequency is less than or equal to B’s low frequency and A’s high frequency is greater than or each to B’s high frequency. Notice that this means that if A equals B, it also contains B.

frequency

the frequency or range to test for inclusion in this range.

Returns

True if this range contains frequency. If frequency is None, the return value will be false.

convert_to(newUnits={'hz': Decimal('1E+9'), 'name': 'GIGAHERTZ', 'symbol': 'GHz'})

Converts both endpoints of this range to the given units.

After this method is complete both endpoints of this range will have units of units, and their values will have been converted accordingly.

newUnits

the new units for the endpoints of this range. If no units are specified, it will be treated as FrequencyUnits.GIGAHERTZ.

Returns

this range.

getCentreFrequency()

Returns the frequency that is midway between the endpoints of this range.

The units for the returned frequency will be the same as those of the high frequency of this range.

Returns

the center of this range.

getGapBetween(other=None)

Returns a new range that represents the region of frequency space between this range and other. If the other range is coincident with, or overlaps, this range, None is returned. If the other range is None, None is returned.

other

another range that might not overlap this one.

Returns

the frequency gap between this range and other.

getOverlapWith(other)

Returns a new range that represents the region of overlap between this range and other. If there is no overlap, None is returned.

other

another range that may overlap this one.

Returns

the overlapping region of this range and other.

getWidth()

Returns the width of this range.

The units for the returned frequency will be the same as those of the high frequency of this range.

Returns

the width of this range.

high

low

overlaps(other=None)

Returns true if this frequency range overlaps with other.

Remember that this range is a closed interval, that is, one that contains both of its endpoints.

If other is None, the return value is false.

other

another range that may overlap this one.

Returns

true if this range overlaps with other.

set(frequency1=None, frequency2=None)

Sets the frequencies of this range.

This method will set the lower value of its range to the lesser of the two parameter values. If either parameter is None, it will be interpreted as a signal to create a new default frequency (0 GHz).

Note that this method makes copies of the parameters; it does not maintain a reference to either parameter. This is done in order to maintain the integrity of the relationship between the starting and ending points of this interval.

frequency1

one endpoint of this range.

frequency2

the other endpoint of this range.

class pipeline.domain.measures.FrequencyUnits

Bases: object

ATTOHERTZ = {'hz': Decimal('1E-18'), 'name': 'ATTOHERTZ', 'symbol': 'aHz'}

CENTIHERTZ = {'hz': Decimal('0.01'), 'name': 'CENTIHERTZ', 'symbol': 'cHz'}

DECAHERTZ = {'hz': Decimal('10'), 'name': 'DECAHERTZ', 'symbol': 'daHz'}

DECIHERTZ = {'hz': Decimal('0.1'), 'name': 'DECIHERTZ', 'symbol': 'dHz'}

ETAHERTZ = {'hz': Decimal('1E+18'), 'name': 'ETAHERTZ', 'symbol': 'EHz'}

FEMTOHERTZ = {'hz': Decimal('1E-15'), 'name': 'FEMTOHERTZ', 'symbol': 'fHz'}

GIGAHERTZ = {'hz': Decimal('1E+9'), 'name': 'GIGAHERTZ', 'symbol': 'GHz'}

HECTOHERTZ = {'hz': Decimal('100'), 'name': 'HECTOHERTZ', 'symbol': 'hHz'}

HERTZ = {'hz': Decimal('1'), 'name': 'HERTZ', 'symbol': 'Hz'}

KILOHERTZ = {'hz': Decimal('1000'), 'name': 'KILOHERTZ', 'symbol': 'kHz'}

MEGAHERTZ = {'hz': Decimal('1E+6'), 'name': 'MEGAHERTZ', 'symbol': 'MHz'}

MICROHERTZ = {'hz': Decimal('0.000001'), 'name': 'MICROHERTZ', 'symbol': '\\u03BCHz'}

MILLIHERTZ = {'hz': Decimal('0.001'), 'name': 'MILLIHERTZ', 'symbol': 'mHz'}

NANOHERTZ = {'hz': Decimal('1E-9'), 'name': 'NANOHERTZ', 'symbol': 'nHz'}

PETAHERTZ = {'hz': Decimal('1E+15'), 'name': 'PETAHERTZ', 'symbol': 'PHz'}

PICOHERTZ = {'hz': Decimal('1E-12'), 'name': 'PICOHERTZ', 'symbol': 'pHz'}

TERAHERTZ = {'hz': Decimal('1E+12'), 'name': 'TERAHERTZ', 'symbol': 'THz'}

YOCTOHERTZ = {'hz': Decimal('1E-24'), 'name': 'YOCTOHERTZ', 'symbol': 'yHz'}

YOTTAHERTZ = {'hz': Decimal('1E+24'), 'name': 'YOTTAHERTZ', 'symbol': 'YHz'}

ZEPTOHERTZ = {'hz': Decimal('1E-21'), 'name': 'ZEPTOHERTZ', 'symbol': 'zHz'}

ZETTAHERTZ = {'hz': Decimal('1E+21'), 'name': 'ZETTAHERTZ', 'symbol': 'ZHz'}

class pipeline.domain.measures.Latitude(value=0, units={'html': '°', 'name': 'DEGREE', 'symbol': 'd', 'units per circle': Decimal('360')})

Bases: pipeline.domain.measures.EquatorialArc

isNorthOf(other)

Returns True if this latitude is north of other.

other

the latitude to be tested.

Returns

True if this latitude is north of other.

isNorthOfEquator()

Returns True if this latitude is north of the equator.

Returns

True if this latitude is north of the equator.

isSouthOf(other)

Returns True if this latitude is south of other.

other

the latitude to be tested.

Returns

True if this latitude is south of other.

isSouthOfEquator()

Returns True if this latitude is south of the equator.

Returns

True if this latitude is south of the equator.

static parse(value)

Returns a new Latitude based on the given text.

See the parse method of Angle for information on the format of text. This Latitude class offers two other formats:

dd:mm:ss.sss dd mm ss.sss

Both of the above are in degrees, arc-minutes, and arc-seconds. For the first alternative form, whitespace is permitted around the colon characters. For the second alternative form, any type and number of whitespace characters may be used in between the three parts.

The parsed value, if not a legal value for latitude, will be normalised in such a way that it is transformed to a legal value. To be legal, magnitude must be greater than or equal to the negative of one-quarter of a circle and less than or equal to one-quarter of a circle, in the given units.

text

a string that will be converted into a latitude.

Returns

a new Latitude. If parsing was successful, the value of the latitude will be based on the parameter string. If it was not, the returned latitude will be of zero degrees.

Throws:

ValueError - if text is not in the expected form.

patt = re.compile('\\s*(?P<degs>[-+]?\\d+)\\s*:?\\s*(?P<mins>\\d+)\\s*:?\\s*(?P<secs>\\d+\\.?\\d*)\\s*')

units

value

class pipeline.domain.measures.LinearVelocity(value=0, units={'mps': Decimal('1000'), 'name': 'KILOMETERS_PER_SECOND', 'symbol': 'km/s'})

Bases: pipeline.domain.measures.ComparableUnit

convert_to(newUnits={'mps': Decimal('1000'), 'name': 'KILOMETERS_PER_SECOND', 'symbol': 'km/s'})

Converts this measure of linear velocity to the new units. After this method is complete this linear veloity will have units of units and its value will have been converted accordingly.

newUnits

the new units for this linear velocity. If newUnits is None an IllegalArgumentException will be thrown.

Returns

this linear velocity. The reason for this return type is to allow code of this nature:

velocity = myLinearVelocity.convert_to(LinearVelocityUnits.Z)

to_units(otherUnits={'mps': Decimal('1000'), 'name': 'KILOMETERS_PER_SECOND', 'symbol': 'km/s'})

Returns the magnitude of this linear velocity in otherUnits.

Note that this method does not alter the state of this linear velocity. Contrast this with convert_to(LinearVelocityUnits).

otherUnits

the units in which to express this linear velocity’s magnitude. If otherUnits is None an IllegalArgumentException will be thrown.

Returns

this linear velocity’s value converted to otherUnits.

units

value

class pipeline.domain.measures.LinearVelocityUnits

Bases: object

KILOMETRES_PER_SECOND = {'mps': Decimal('1000'), 'name': 'KILOMETERS_PER_SECOND', 'symbol': 'km/s'}

METRES_PER_SECOND = {'mps': Decimal('1'), 'name': 'METRES_PER_SECOND', 'symbol': 'm/s'}

Z = {'mps': Decimal('299792458'), 'name': 'Z', 'symbol': 'Z'}

class pipeline.domain.measures.Longitude(value=0, units={'html': '&#x00B0;', 'name': 'DEGREE', 'symbol': 'd', 'units per circle': Decimal('360')})

Bases: pipeline.domain.measures.EquatorialArc

isEastOf(other)

Returns true if this longitude is east of other.

One longitude is east of another if there are fewer lines of longitude to cross by travelling eastward along a given latitude than there would be by travelling westward along that same latitude.

Two special cases are worth noting. First, a longitude that is equal to this one is neither east nor west of this one. Second, a longitude that is opposite this one is both east and west of this one.

other

the longitude to be tested.

Returns

True if this longitude is east of other.

isOpposite(other)

Returns True if this longitude and other are separated by one half circle.

other

the other longitude to be tested.

Returns

True if other is separated from this longitude by one half circle.

isWestOf(other)

Returns True if this longitude is west of other.

One longitude is west of another if there are fewer lines of longitude to cross by travelling westward along a given latitude than there would be by travelling eastward along that same latitude.

Two special cases are worth noting. First, a longitude that is equal to this one is neither east nor west of this one. Second, a longitude that is opposite this one is both east and west of this one.

other

the longitude to be tested.

Returns

True if this longitude is west of other.

static parse(value)

Returns a new longitude based on the given text.

See the parse method of Angle for information on the format of text. This Longitude class offers two other formats:

hh:mm:ss.sss hh mm ss.sss

Both of the above are in hours, minutes, and seconds. For the first alternative form, whitespace is permitted around the colon characters. For the second alternative form, any type and number of whitespace characters may be used in between the three parts.

The parsed value, if not a legal value for longitude, will be normalised in such a way that it is transformed to a legal value. To be

legal, magnitude must be greater than or equal zero and less than or equal to one full circle, in the given units.

text

a string that will be converted into a longitude.

Returns

a new Longitude. If parsing was successful, the value of the Longitude will be based on the parameter string. If it was not, the returned longitude will be of zero degrees.

Throws:

ValueError - if text is not in the expected form.

patt = re.compile('\\s*(?P<hours>\\d+)\\s*:?\\s*(?P<mins>\\d+)\\s*:?\\s*(?P<secs>\\d+\\.?\\d*)\\s*')

units

value

class pipeline.domain.measures.TemporalCollection

Bases: object

get(when=None)

Returns the value that was effective on the given date

put(at, item)

class pipeline.domain.measures.TimeInterval(start=None, end=None)

Bases: object

FOREVER = datetime.datetime(9999, 12, 31, 0, 0)

contains(time)

Returns True if time is contained in this interval.

Note that this interval is half-open; it does not include its ending point. Note also that an interval that is equal to this one is not contained by this one. The best analogy is that of a rigid box with infinitely thin walls: a box that is exactly the same as another cannot fit inside it.

time

the datetime or TimeInterval to be tested for containment.

Returns

True if time is contained in this interval.

end

isEmpty()

Returns True if this TimeInterval is empty

overlaps(ti)

Returns True if this interval overlaps with the given interval.

start

static startingFrom(start)

Returns an open-ended TimeInterval starting from the given time.

static startingFromNow()

Returns an open-ended TimeInterval starting from now.

pipeline.domain.observingrun module

class pipeline.domain.observingrun.ObservingRun

Bases: object

add_measurement_set(ms)

property end_datetime

property end_time

property execblock_ids

get_fields(names=None)

Returns fields matching the given arguments from all measurement sets.

get_measurement_sets(names=None, intents=None, fields=None, imaging_preferred=False)

Returns measurement sets matching the given arguments.

get_ms(name=None, intent=None)

Returns the first measurement set matching the given identifier. Identifier precedence is name then intent.

static get_real_spw_id_by_name(spw_name, target_ms)

Parameters

• spw_name (string) – the spw name to convert

• target_ms (domain.MeasurementSet) – the MS to map spw_name to

get_real_spwsel(spwsel, vis)

Parameters

• spwsel (list of strings) – the list of spw selections to convert

• vis (list of MS names) – the list of MS names to map spwsel to

get_virtual_spw_id_by_name(spw_name)

Parameters

spw_name (string) – the spw name to convert

property observers

property project_ids

real2virtual_spw_id(spw_id, target_ms)

Parameters

• spw_id (integer) – the spw id to convert

• target_ms (domain.MeasurementSet) – the MS to map spw_id to

property schedblock_ids

property start_datetime

property start_time

virtual2real_spw_id(spw_id, target_ms)

Parameters

• spw_id (integer) – the spw id to convert

• target_ms (domain.MeasurementSet) – the MS to map spw_id to

pipeline.domain.polarization module

class pipeline.domain.polarization.Polarization(pol_id, num_corr, corr_type, corr_product)

Bases: object

pipeline.domain.scan module

class pipeline.domain.scan.Scan(id=None, antennas=None, intents=None, fields=None, states=None, data_descriptions=None, scan_times=None)

Bases: object

Class containing info about a single scan.

property end_time

exposure_time(spw_id)

mean_interval(spw_id)

property spws

property start_time

property time_on_source

pipeline.domain.singledish module

class pipeline.domain.singledish.MSReductionGroupDesc(spw_name=None, min_frequency=None, max_frequency=None, nchan=None, field=None)

Bases: list

add_linelist(linelist, ms, antenna_id, spw_id, field_id=None, channelmap_range=None)

add_member(ms, antenna_id, spw_id, field_id=None)

property field_name

property frequency_range

get_iteration(ms, antenna_id, spw_id, field_id=None)

iter_countup(ms, antenna_id, spw_id, field_id=None)

merge(other)

class pipeline.domain.singledish.MSReductionGroupMember(ms, antenna_id, spw_id, field_id=None)

Bases: object

add_linelist(linelist, pols=None, channelmap_range=None)

property antenna

property antenna_name

property field

property field_name

iter_countup()

iter_reset()

property npol

property spw

pipeline.domain.source module

class pipeline.domain.source.Source(source_id, name, direction, proper_motion, is_eph_obj)

Bases: object

property dec

property direction

property frame

property gb

property gl

property intents

property latitude

property longitude

property pm_x

property pm_y

property proper_motion

property ra

pipeline.domain.spectralwindow module

class pipeline.domain.spectralwindow.ArithmeticProgression(start, delta, num_terms)

Bases: object

A representation of an arithmetic progression that can generate sequence elements on demand.

delta

num_terms

start

class pipeline.domain.spectralwindow.Channel(start, end, effective_bw)

Bases: object

Representation of a channel within a spectral window.

This object can be considered as a FrequencyRange object plus an effective bandwidth property. It provides the same interface as a FrequencyRange.

contains(frequency)

convert_to(newUnits={'hz': Decimal('1E+9'), 'name': 'GIGAHERTZ', 'symbol': 'GHz'})

effective_bw

frequency_range

getCentreFrequency()

getGapBetween(other)

getOverlapWith(other)

getWidth()

property high

property low

overlaps(other)

set(frequency1, frequency2)

class pipeline.domain.spectralwindow.ChannelList(chan_freqs, chan_widths, effbw)

Bases: object

A container/generator for Channel objects.

A spectral window can contain thousands of channels. Rather than store all of these objects, a ChannelList generates and returns them lazily, on-demand.

class pipeline.domain.spectralwindow.SpectralWindow(spw_id, name, spw_type, bandwidth, ref_freq, mean_freq, chan_freqs, chan_widths, chan_effective_bws, sideband, baseband, receiver, freq_lo, band='Unknown', transitions=None)

Bases: object

SpectralWindow is a logical representation of a spectral window.

id

the numerical identifier of this spectral window within the SPECTRAL_WINDOW subtable of the measurement set

channels

the number of channels

bandwidth

the total bandwidth

ref_frequency

the reference frequency

chan_width

the channel width

intents

the observing intents that have been observed using this spectral window

band

bandwidth

baseband

property centre_frequency

channel_range(minfreq, maxfreq)

# More work on this in future minfreq – measures.Frequency object in HERTZ maxfreq – measures.Frequency object in HERTZ

channels

property frame

freq_lo

id

intents

property max_frequency

mean_frequency

property min_frequency

name

property num_channels

receiver

ref_frequency

sideband

transitions

type

class pipeline.domain.spectralwindow.SpectralWindowWithChannelSelection(subject, channels)

Bases: object

SpectralWindowWithChannelSelection decorates a SpectralWindow so that the spectral window ID also contains a channel selection.

property id

pipeline.domain.spectralwindow.compress(values)

Compress (if possible) a sequence of values.

If the numbers in the given list constitute an arithmetic progression, return an ArithmeticProgression object that summarises it as such. If the list cannot be summarised as a simple arithmetic progression, return the list as given.

pipeline.domain.state module

class pipeline.domain.state.State(state_id, obs_mode)

Bases: object

get_obs_mode_for_intent(intent)

id

property intents

obs_mode

obs_mode_mapping = {}

property reduction_intents

class pipeline.domain.state.StateALMA(state_id, obs_mode)

Bases: pipeline.domain.state.State

id

obs_mode

obs_mode_mapping = {'CALIBRATE_AMPLI#ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_AMPLI.ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_AMPLI_ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_ATMOSPHERE#AMBIENT': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE#HOT': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE#OFF_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE#ON_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE.OFF_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE.ON_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE_OFF_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE_ON_SOURCE': 'ATMOSPHERE', 'CALIBRATE_BANDPASS#ON_SOURCE': 'BANDPASS', 'CALIBRATE_BANDPASS.ON_SOURCE': 'BANDPASS', 'CALIBRATE_BANDPASS_ON_SOURCE': 'BANDPASS', 'CALIBRATE_DELAY#ON_SOURCE': 'CHECK', 'CALIBRATE_DELAY.ON_SOURCE': 'CHECK', 'CALIBRATE_DELAY_ON_SOURCE': 'CHECK', 'CALIBRATE_FLUX#ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_FLUX.ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_FLUX_ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_FOCUS#ON_SOURCE': 'FOCUS', 'CALIBRATE_FOCUS.ON_SOURCE': 'FOCUS', 'CALIBRATE_FOCUS_ON_SOURCE': 'FOCUS', 'CALIBRATE_PHASE#ON_SOURCE': 'PHASE', 'CALIBRATE_PHASE.ON_SOURCE': 'PHASE', 'CALIBRATE_PHASE_ON_SOURCE': 'PHASE', 'CALIBRATE_POINTING#ON_SOURCE': 'POINTING', 'CALIBRATE_POINTING.ON_SOURCE': 'POINTING', 'CALIBRATE_POINTING_ON_SOURCE': 'POINTING', 'CALIBRATE_POLARIZATION#ON_SOURCE': 'POLARIZATION', 'CALIBRATE_POLARIZATION.ON_SOURCE': 'POLARIZATION', 'CALIBRATE_POLARIZATION_ON_SOURCE': 'POLARIZATION', 'CALIBRATE_POL_ANGLE#ON_SOURCE': 'POLANGLE', 'CALIBRATE_POL_ANGLE.ON_SOURCE': 'POLANGLE', 'CALIBRATE_POL_ANGLE_ON_SOURCE': 'POLANGLE', 'CALIBRATE_POL_LEAKAGE#ON_SOURCE': 'POLLEAKAGE', 'CALIBRATE_POL_LEAKAGE.ON_SOURCE': 'POLLEAKAGE', 'CALIBRATE_POL_LEAKAGE_ON_SOURCE': 'POLLEAKAGE', 'CALIBRATE_SIDEBAND_RATIO#OFF_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO#ON_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO.OFF_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO.ON_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO_OFF_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO_ON_SOURCE': 'SIDEBAND', 'CALIBRATE_TARGET#ON_SOURCE': 'TARGET', 'CALIBRATE_TARGET.ON_SOURCE': 'TARGET', 'CALIBRATE_TARGET_ON_SOURCE': 'TARGET', 'CALIBRATE_WVR#ON_SOURCE': 'WVR', 'CALIBRATE_WVR.ON_SOURCE': 'WVR', 'CALIBRATE_WVR_ON_SOURCE': 'WVR', 'OBSERVE_CHECK_SOURCE#ON_SOURCE': 'CHECK', 'OBSERVE_CHECK_SOURCE.ON_SOURCE': 'CHECK', 'OBSERVE_CHECK_SOURCE_ON_SOURCE': 'CHECK', 'OBSERVE_TARGET#OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET#ON_SOURCE': 'TARGET', 'OBSERVE_TARGET.OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET.ON_SOURCE': 'TARGET', 'OBSERVE_TARGET_OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET_ON_SOURCE': 'TARGET'}

class pipeline.domain.state.StateALMACycle0(state_id, obs_mode)

Bases: pipeline.domain.state.StateALMA

id

obs_mode

class pipeline.domain.state.StateAPEX(state_id, obs_mode)

Bases: pipeline.domain.state.State

id

obs_mode

obs_mode_mapping = {'OBSERVE_TARGET#ON_SOURCE': 'TARGET'}

class pipeline.domain.state.StateFactory(observatory, start=None)

Bases: object

create_state(state_id, obs_mode)

class pipeline.domain.state.StateNAOJ(state_id, obs_mode)

Bases: pipeline.domain.state.State

id

obs_mode

obs_mode_mapping = {'CALIBRATE_ATMOSPHERE#R_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE#SKY_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE#ZERO_SOURCE': 'ATMOSPHERE', 'OBSERVE_TARGET#OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET#ON_SOURCE': 'TARGET'}

class pipeline.domain.state.StateSMT(state_id, obs_mode)

Bases: pipeline.domain.state.State

id

obs_mode

obs_mode_mapping = {'OBSERVE_TARGET#ON_SOURCE': 'TARGET'}

class pipeline.domain.state.StateVLA(state_id, obs_mode)

Bases: pipeline.domain.state.State

id

obs_mode

obs_mode_mapping = {'CALIBRATE_AMPLI#ON_SOURCE': 'PHASE', 'CALIBRATE_AMPLI#UNSPECIFIED': 'PHASE', 'CALIBRATE_AMPLI.ON_SOURCE': 'PHASE', 'CALIBRATE_AMPLI_ON_SOURCE': 'PHASE', 'CALIBRATE_ATMOSPHERE#ON_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE.ON_SOURCE': 'ATMOSPHERE', 'CALIBRATE_ATMOSPHERE_ON_SOURCE': 'ATMOSPHERE', 'CALIBRATE_BANDPASS#ON_SOURCE': 'BANDPASS', 'CALIBRATE_BANDPASS#UNSPECIFIED': 'BANDPASS', 'CALIBRATE_BANDPASS.ON_SOURCE': 'BANDPASS', 'CALIBRATE_BANDPASS_ON_SOURCE': 'BANDPASS', 'CALIBRATE_FLUX#ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_FLUX#UNSPECIFIED': 'AMPLITUDE', 'CALIBRATE_FLUX.ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_FLUX_ON_SOURCE': 'AMPLITUDE', 'CALIBRATE_FOCUS#ON_SOURCE': 'FOCUS', 'CALIBRATE_FOCUS.ON_SOURCE': 'FOCUS', 'CALIBRATE_FOCUS_ON_SOURCE': 'FOCUS', 'CALIBRATE_PHASE#ON_SOURCE': 'PHASE', 'CALIBRATE_PHASE#UNSPECIFIED': 'PHASE', 'CALIBRATE_PHASE.ON_SOURCE': 'PHASE', 'CALIBRATE_PHASE_ON_SOURCE': 'PHASE', 'CALIBRATE_POINTING#ON_SOURCE': 'POINTING', 'CALIBRATE_POINTING.ON_SOURCE': 'POINTING', 'CALIBRATE_POINTING_ON_SOURCE': 'POINTING', 'CALIBRATE_POLARIZATION#ON_SOURCE': 'POLARIZATION', 'CALIBRATE_POLARIZATION#UNSPECIFIED': 'POLARIZATION', 'CALIBRATE_POLARIZATION.ON_SOURCE': 'POLARIZATION', 'CALIBRATE_POLARIZATION_ON_SOURCE': 'POLARIZATION', 'CALIBRATE_POL_ANGLE#ON_SOURCE': 'POLANGLE', 'CALIBRATE_POL_ANGLE#UNSPECIFIED': 'POLANGLE', 'CALIBRATE_POL_ANGLE.ON_SOURCE': 'POLANGLE', 'CALIBRATE_POL_ANGLE_ON_SOURCE': 'POLANGLE', 'CALIBRATE_POL_LEAKAGE#ON_SOURCE': 'POLLEAKAGE', 'CALIBRATE_POL_LEAKAGE#UNSPECIFIED': 'POLLEAKAGE', 'CALIBRATE_POL_LEAKAGE.ON_SOURCE': 'POLLEAKAGE', 'CALIBRATE_POL_LEAKAGE_ON_SOURCE': 'POLLEAKAGE', 'CALIBRATE_SIDEBAND_RATIO#ON_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO.ON_SOURCE': 'SIDEBAND', 'CALIBRATE_SIDEBAND_RATIO_ON_SOURCE': 'SIDEBAND', 'CALIBRATE_TARGET#ON_SOURCE': 'TARGET', 'CALIBRATE_TARGET.ON_SOURCE': 'TARGET', 'CALIBRATE_TARGET_ON_SOURCE': 'TARGET', 'CALIBRATE_WVR#ON_SOURCE': 'WVR', 'CALIBRATE_WVR.ON_SOURCE': 'WVR', 'CALIBRATE_WVR_ON_SOURCE': 'WVR', 'OBSERVE_TARGET#OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET#ON_SOURCE': 'TARGET', 'OBSERVE_TARGET#UNSPECIFIED': 'TARGET', 'OBSERVE_TARGET.OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET.ON_SOURCE': 'TARGET', 'OBSERVE_TARGET_OFF_SOURCE': 'REFERENCE', 'OBSERVE_TARGET_ON_SOURCE': 'TARGET', 'SYSTEM_CONFIGURATION': 'SYSTEM_CONFIGURATION', 'SYSTEM_CONFIGURATION#UNSPECIFIED': 'SYSTEM_CONFIGURATION', 'UNSPECIFIED#UNSPECIFIED': 'UNSPECIFIED#UNSPECIFIED'}

pipeline.domain.unitformat module

Format values that are usually associated with a unit.

class pipeline.domain.unitformat.UnitFormat(prefer_integers=False)

Bases: object

addUnitOfMagnitude(magnitude, format, html=None)

Adds a unit to this format. For example, to add support for centimetres to a UnitFormat of metric length, use magnitude of 0.01d (ie 1/100th of a metre) and number format ‘###0.# cm’.

bestUnitForObject(number)

format(number)

html(number)

class pipeline.domain.unitformat.UnitOfMagnitude(magnitude, format, html)

Bases: object

Models a unit of magnitude such as ‘Kilobyte’, ‘milimetre’ or ‘hectare’.

adjust(number)

pipeline.domain.unitformat.get_frequency_format(precision)

Module contents