#
# stub class definition file for docstring parsing
#
[docs]class measures:
"""
measures tool
"""
[docs] def measures(self):
"""
Construct measures tool
Create a measures tool on the specified host (or by default the
host you are running on).
"""
pass
[docs] def dirshow(self, v=''):
"""
Show direction measure as a string.
dirshow will convert a direction measure to a string
.. rubric:: Parameters
- ``v (record='')`` - a direction measure value to be converted to string
"""
pass
[docs] def show(self, v='', refcode=True):
"""
Show a measure as a string
show will convert a measure to a string.
All measures are catered for (at this moment {\em direction, position, epoch,
radialvelocity, frequency, doppler, baseline, uvw, earthmagnetic} ).
.. rubric:: Parameters
- ``v (record='')`` - measure value to be converted to string
- ``refcode (bool=True)`` - add the reference code to output
"""
pass
[docs] def epoch(self, rf='UTC', v0='', off=''):
"""
define an epoch measure
epoch defines an epoch measure from the CLI. It has to specify a
reference code, an epoch quantity value (see introduction for the
action on a scalar quantity with either a vector or scalar value),
and optionally it can specify an offset, which in itself has to be an
epoch. Allowable reference codes are:
{\em UTC TAI LAST LMST GMST1 GAST UT1 UT2 TDT TCG TDB TCB}.\\
Note that additional ones may become available. Check in \casa\ with:
\begin{verbatim}
print "\t----\t epoch Ex 1 \t----"
print me.listcodes(me.epoch())
#{'normal': ['LAST', 'LMST', 'GMST1', 'GAST', 'UT1', 'UT2', 'UTC', 'TAI',
# 'TDT', 'TCG', 'TDB', 'TCB', 'IAT', 'GMST', 'TT', 'ET', 'UT'], 'extra': []}
#
\end{verbatim}
See quantity for possible time formats.
.. rubric:: Parameters
- ``rf (string='UTC')`` - reference code
- ``v0 (variant='')`` - epoch value
- ``off (record='')`` - optional offset epoch measure
"""
pass
[docs] def direction(self, rf='J2000', v0='', v1='', off=''):
"""
define a direction measure
direction defines a direction measure from the CLI. It has to specify a
reference code, direction quantity values (see introduction for the action on a
scalar quantity with either a vector or scalar value),
and optionally it can specify an
offset, which in itself has to be a direction. Allowable reference codes are:
{\em J2000 JMEAN JTRUE APP B1950 BMEAN BTRUE GALACTIC HADEC AZEL
SUPERGAL ECLIPTIC MECLIPTIC TECLIPTIC MERCURY
VENUS MARS JUPITER SATURN URANUS NEPTUNE PLUTO MOON SUN COMET}.\\
Note that additional ones may become available. Check in \casa\ with:
\begin{verbatim}
print "\t----\t direction Ex 1 \t----"
print me.listcodes(me.direction())
#{'normal': ['J2000', 'JMEAN', 'JTRUE', 'APP', 'B1950', 'BMEAN',
#'BTRUE', 'GALACTIC', 'HADEC', 'AZEL', 'AZELSW', 'AZELNE', 'AZELGEO',
#'AZELSWGEO', 'AZELNEGEO', 'JNAT', 'ECLIPTIC', 'MECLIPTIC',
#'TECLIPTIC', 'SUPERGAL', 'ITRF', 'TOPO', 'ICRS'], 'extra': ['MERCURY',
#'VENUS', 'MARS', 'JUPITER', 'SATURN', 'URANUS', 'NEPTUNE', 'PLUTO',
#'SUN', 'MOON', 'COMET']}
\end{verbatim}
The direction quantity values should be longitude(angle) and
latitude(angle) (none needed for planets: the frame epoch defines coordinates).
See quantity for possible angle formats.
.. rubric:: Parameters
- ``rf (string='J2000')`` - reference code
- ``v0 (variant='')`` - longitude
- ``v1 (variant='')`` - latitude
- ``off (record='')`` - optional offset direction measure
"""
pass
[docs] def getvalue(self, v=''):
"""
get the value of a measure
getvalue gets the actual implementation value of the measure.
.. rubric:: Parameters
- ``v (record='')`` - measure (array of measures)
"""
pass
[docs] def gettype(self, v=''):
"""
get the type of a measure
gettype gets the actual type of the measure.
.. rubric:: Parameters
- ``v (record='')`` - measure (array of measures)
"""
pass
[docs] def getref(self, v=''):
"""
get the reference code of a measure
gettype gets the actual reference code of the measure.
.. rubric:: Parameters
- ``v (record='')`` - measure (array of measures)
"""
pass
[docs] def getoffset(self, v=''):
"""
get the offset of a measure
getoff gets the actual offset of the measure (as a measure) or F if no offset
given.
.. rubric:: Parameters
- ``v (record='')`` - measure (array of measures)
"""
pass
[docs] def cometname(self):
"""
get the current comet name
cometname gets the name of the current comet (if any).
"""
pass
[docs] def comettype(self):
"""
get the current comet table type
comettype gets the comet table type (apparent or topocentric)
"""
pass
[docs] def cometdist(self):
"""
get the distance of the current comet in the current frame
cometdist returns the distance in AU of the current comet in the current frame,
as a quantity. It will return -1 AU on failure!
"""
pass
[docs] def comettopo(self):
"""
get the current comet table coordinates
comettopo gets the comet table's topographic coordinates used.
"""
pass
[docs] def framecomet(self, v=''):
"""
set the current comet table
framecomet will put the specified comet table in the frame.
.. rubric:: Parameters
- ``v (string='')`` - name of a table
"""
pass
[docs] def position(self, rf='WGS84', v0='', v1='', v2='', off=''):
"""
define a position measure
position defines a position measure from the CLI. It has to specify a
reference code, position quantity values (see introduction for the action on a
scalar quantity with either a vector or scalar value),
and optionally it can specify an
offset, which in itself has to be a position. Allowable reference codes are:
{\em WGS84 ITRF} (World Geodetic System and International Terrestrial
Reference Frame).\\
Note that additional ones may become available. Check in \casa\ with:
\begin{verbatim}
print "\t----\t position Ex 1 \t----"
print me.listcodes(me.position())
#{'normal': ['ITRF', 'WGS84'], 'extra': []}
\end{verbatim}
The position quantity values should be either longitude
(angle), latitude(angle) and height(length); or x,y,z (length).
See quantity for possible angle formats.
.. rubric:: Parameters
- ``rf (string='WGS84')`` - reference code
- ``v0 (variant='')`` - longitude or x
- ``v1 (variant='')`` - latitude or y
- ``v2 (variant='')`` - height or z
- ``off (record='')`` - optional offset position measure
"""
pass
[docs] def observatory(self, name='ALMA'):
"""
get position of an observatory
observatory will give you the position of an observatory as given in the
system. At the time of writing the following observatories are recognised
(but check e.g. the position GUI for currently known ones, or the
me.obslist() tool function):
{\em'ALMA' 'ARECIBO' 'ATCA' 'BIMA' 'CLRO' 'DRAO' 'DWL' 'GB' 'GBT' 'GMRT'
'IRAM PDB' 'IRAM_PDB' 'JCMT' 'MOPRA' 'MOST' 'NRAO12M' 'NRAO_GBT' 'PKS'
'SAO SMA' 'SMA' 'VLA' 'VLBA' 'WSRT' 'ATF' 'ATA' 'CARMA' 'ACA' 'OSF'
'OVRO_MMA' 'EVLA' 'ASKAP' 'APEX' 'SMT' 'NRO' 'ASTE' 'LOFAR' 'MeerKAT'
'KAT-7' 'EVN' 'LWA1' 'PAPER_SA' 'PAPER_GB' 'e-MERLIN' 'MERLIN2'
'Effelsberg' 'MWA32T' }.
.. rubric:: Parameters
- ``name (string='ALMA')`` - observatory name - case insensitive
"""
pass
[docs] def obslist(self):
"""
get a list of known observatories
obslist will give you an array of strings of the
observatories known in the Observatories table.
"""
pass
[docs] def linelist(self):
"""
get a list of known spectral lines
linelist will give you a string with a space separated list of spectral lines
known in the Lines table.
A number of lines are available now, but tables with many lines are
already online, and will be interfaced once a nomenclature can be defined for
the tens of thousands of lines.
"""
pass
[docs] def spectralline(self, name='HI'):
"""
get frequency of a spectral line
spectralline will give you the frequency of a spectral line. The known list
can be obtained by me.linelist().
.. rubric:: Parameters
- ``name (string='HI')`` - name
"""
pass
[docs] def sourcelist(self):
"""
get a list of known sources
sourcelist will give you a string with the space separated list of sources
known in the Sources table.
"""
pass
[docs] def source(self, name='1934-638'):
"""
get direction of a source
source will give you the direction of a source. The known list
can be obtained by me.sourcelist().
.. rubric:: Parameters
- ``name (variant='1934-638')`` - name
"""
pass
[docs] def frequency(self, rf='LSRK', v0='', off=''):
"""
define a frequency measure
frequency defines a frequency measure from the CLI. It has to specify a
reference code, frequency quantity value (see introduction for the action on a
scalar quantity with either a vector or scalar value),
and optionally it can specify an
offset, which in itself has to be a frequency. Allowable reference codes are:
{\em REST LSRK LSRD BARY GEO TOPO GALACTO LGROUP CMB}.\\
Note that additional ones may become available. Check in \casa\ with:
\begin{verbatim}
print "\t----\t frequency Ex 1 \t----"
print me.listcodes(me.frequency())
#{'normal': ['REST', 'LSRK', 'LSRD', 'BARY', 'GEO', 'TOPO',
# 'GALACTO', 'LGROUP', 'CMB'], 'extra': []}
\end{verbatim}
The frequency quantity values should be in one of the recognised units
(examples all give same frequency):
\begin{itemize}
\item value with time units: a period (0.5s)
\item value as frequency: 2Hz
\item value in angular frequency: 720deg/s
\item value as length: 149896km
\item value as wave number: 4.19169e-8m-1
\item value as energy (h.nu): 8.27134e-9ueV
\item value as momentum: 4.42044e-42kg.m
\end{itemize}
.. rubric:: Parameters
- ``rf (string='LSRK')`` - reference code
- ``v0 (variant='')`` - frequency/wavelength/\ldots
- ``off (record='')`` - optional offset frequency measure
"""
pass
[docs] def doppler(self, rf='RADIO', v0='', off=''):
"""
define a doppler measure
doppler defines a doppler measure from the CLI. It has to specify a
reference code, doppler quantity value (see introduction for the action on a
scalar quantity with either a vector or scalar value),
and optionally it can specify an offset,
which in itself has to be a doppler. Allowable reference codes are:
{\em RADIO Z RATIO BETA GAMMA OPTICAL TRUE RELATIVISTIC}.\\
Note that additional ones may become available. Check in \casa\ with:
\begin{verbatim}
print "\t----\t doppler Ex 1 \t----"
print me.listcodes(me.doppler())
#{'normal': ['RADIO', 'Z', 'RATIO', 'BETA', 'GAMMA', 'OPTICAL',
# 'TRUE', 'RELATIVISTIC'], 'extra': []}
\end{verbatim}
The doppler quantity values should be either non-dimensioned to specify a
ratio of the light velocity, or in velocity.
.. rubric:: Parameters
- ``rf (string='RADIO')`` - reference code
- ``v0 (variant='')`` - doppler ratio/velocity
- ``off (record='')`` - optional offset doppler measure
"""
pass
[docs] def radialvelocity(self, rf='LSRK', v0='', off=''):
"""
define a radialvelocity measure
radialvelocity defines a radialvelocity measure from the CLI. It has to
specify a reference code, radialvelocity quantity value (see introduction for
the action on a
scalar quantity with either a vector or scalar value),
and optionally it
can specify an offset, which in itself has to be a radialvelocity.
Allowable reference codes are:
{\em LSRK LSRD BARY GEO TOPO GALACTO LGROUP CMB}.\\
Note that additional ones may become available. Check in \casa\ with:
\begin{verbatim}
print "\t----\t radialvelocity Ex 1 \t----"
print me.listcodes(me.radialvelocity())
# Out[17]:
#{'extra': [],
# 'normal': ['LSRK', 'LSRD', 'BARY', 'GEO', 'TOPO', 'GALACTO',
# 'LGROUP', 'CMB']}
\end{verbatim}
The radialvelocity quantity values should be given as velocity.
.. rubric:: Parameters
- ``rf (string='LSRK')`` - reference code
- ``v0 (variant='')`` - radial velocity
- ``off (record='')`` - optional offset radialvelocity measure
"""
pass
[docs] def shift(self, v='', offset='0deg', pa='0deg'):
"""
Shift a direction measure by an offset angle at a position angle.
This method calculates the direction measure located at the specified offset angular amount along the specified
position angle from the specified direction measure.
.. rubric:: Parameters
- ``v (record='')`` - The direction measure to shift, represented as a record.
- ``offset (variant='0deg')`` - The angular offset, represented as a quantity record or string.
- ``pa (variant='0deg')`` - Position angle of the offset, measured from the positive latitude axis through the positive longitude axis.
"""
pass
[docs] def uvw(self, rf='ITRF', v0='', v1='', v2='', off=''):
"""
define a uvw measure
uvw defines a uvw measure from the CLI. It has to specify a
reference code, uvw quantity values (see introduction for the action on a
scalar quantity with either a vector or scalar value), and optionally it can specify an
offset, which in itself has to be a uvw. Allowable reference codes are
ITRF and the direction ones.\\
Note that additional ones may become available. Check in \casa\ with:
print "\t----\t uvw Ex 1 \t----"
print me.listcodes(me.uvw())
# {'normal': array(['J2000', 'JMEAN', 'JTRUE', 'APP', 'B1950', 'B1950_VLA', 'BMEAN',
'BTRUE', 'GALACTIC', 'HADEC', 'AZEL', 'AZELSW', 'AZELNE', 'AZELGEO',
'AZELSWGEO', 'AZELNEGEO', 'JNAT', 'ECLIPTIC', 'MECLIPTIC',
'TECLIPTIC', 'SUPERGAL', 'ITRF', 'TOPO', 'ICRS'],
dtype='|S10'), 'extra': array([],
dtype='|S1')}
The uvw quantity values should be either longitude
(angle), latitude(angle) and height(length); or x,y,z (length).
See quantity for possible angle formats.
.. rubric:: Parameters
- ``rf (string='ITRF')`` - reference code
- ``v0 (variant='')`` - longitude or x
- ``v1 (variant='')`` - latitude or y
- ``v2 (variant='')`` - height or z
- ``off (record='')`` - optional offset uvw measure
"""
pass
[docs] def touvw(self, v=''):
"""
calculate a uvw measure from a baseline
touvw calculates a uvw measure from a baseline. Note that the
baseline does not have to be a proper {\em baseline}, but can be a
series of positions (to call positions baselines see
asbaseline ) for speed reasons:
operations are linear and can be done on positions, which are
converted to baseline values at the end (with
expand ).
Whatever the reference code of the baseline, the returned {\em uvw} will be
given in J2000. If the {\em dot} argument is given, that variable
will be filled with a quantity array consisting of the time
derivative of the uvw (note that only the sidereal rate is taken
into account; not precession, earth tides and similar variations,
which are much smaller). If the {\em xyz} variable is given, it will
be filled with the quantity values of the uvw measure.
The values of the input baselines can be given as a quantity
vector per x, y or z value.
uvw coordinates are calculated for a certain direction in the sky;
hence the frame has to contain the direction for the calculation to
work. Since the baseline and the sky rotate with respect of each
other, the time should be specified as well.
.. rubric:: Parameters
- ``v (record='')`` - baseline measure
"""
pass
[docs] def expand(self, v=''):
"""
expand n positions to n*(n-1)/2 baselines
expand calculates the differences between a series of given measure
values: it calculates baseline values from position values. The
returned value is a measure, but the value of the optional output
variable {\em xyz} will be set to an array of values.
.. rubric:: Parameters
- ``v (record='')`` - measure (baseline, position or uvw measure)
"""
pass
[docs] def earthmagnetic(self, rf='IGRF', v0='', v1='', v2='', off=''):
"""
define an earthmagnetic measure
earthmagnetic defines an earthmagnetic measure from the CLI. It needs
a reference code, earthmagnetic quantity values
(see introduction for the action on a
scalar quantity with either a vector or scalar value) if the reference code is not
for a model, and optionally it
can specify an offset, which in itself has to be a earthmagnetic. In general
you specify a model (IGRF is the default and the only one known) and convert
it to an explicit field. (See
http://fdd.gsfc.nasa.gov/IGRF.html
for information on the International Geomagnetic Reference Field). The
earthmagnetic quantity values should be either longitude (angle),
latitude(angle) and length(field strength); or x,y,z (field).
See quantity for possible angle formats.
.. rubric:: Parameters
- ``rf (string='IGRF')`` - reference code
- ``v0 (variant='')`` - Field strength
- ``v1 (variant='')`` - longitude
- ``v2 (variant='')`` - latitude
- ``off (record='')`` - optional offset earthmagnetic measure
"""
pass
[docs] def baseline(self, rf='ITRF', v0='', v1='', v2='', off=''):
"""
define a baseline measure
baseline defines a baseline measure from the CLI. It has to specify a
reference code, baseline quantity values (see introduction for the action on a
scalar quantity with either a vector or scalar value, and when a vector of
quantities is given), and optionally it can specify an
offset, which in itself has to be a baseline. Allowable reference codes are
ITRF and the direction ones.\\
Note that additional ones may become available. Check in \casa\ with:
print "\t----\t baseline Ex 1 \t----"
print me.listcodes(me.baseline())
# {'normal': array(['J2000', 'JMEAN', 'JTRUE', 'APP', 'B1950', 'B1950_VLA', 'BMEAN',
# 'BTRUE', 'GALACTIC', 'HADEC', 'AZEL', 'AZELSW', 'AZELNE', 'AZELGEO',
# 'AZELSWGEO', 'AZELNEGEO', 'JNAT', 'ECLIPTIC', 'MECLIPTIC',
# 'TECLIPTIC', 'SUPERGAL', 'ITRF', 'TOPO', 'ICRS'],
# dtype='|S10'), 'extra': array([],
# dtype='|S1')}
The baseline quantity values should be either longitude
(angle), latitude(angle) and height(length); or x,y,z (length).
See quantity for possible angle formats.
.. rubric:: Parameters
- ``rf (string='ITRF')`` - reference code
- ``v0 (variant='')`` - longitude or x
- ``v1 (variant='')`` - latitude or y
- ``v2 (variant='')`` - height or z
- ``off (record='')`` - optional offset baseline measure
"""
pass
[docs] def asbaseline(self, pos=''):
"""
define a baseline from a position measure
asbaseline converts a position measure into a baseline measure. No
actual baseline is calculated, since operations can be done on
positions, with subtractions to obtain baselines at a later stage.
.. rubric:: Parameters
- ``pos (record='')`` - position measure
"""
pass
[docs] def listcodes(self, ms=''):
"""
get known reference code names (list indices do not necessarily correspond to enumeration indices)
listcodes will produce the known reference codes for a specified measure
type. It will return a record with two entries. The first is a string vector
of all normal codes; the second a string vector (maybe empty) with all extra
codes (like planets).
NOTE: Synonyms and different code groups may be present in the code name lists.
The indices in these lists therefore do not necessarily correspond to
the internal CASA enumeration indices.
.. rubric:: Parameters
- ``ms (record='')`` - the measure type for which to list
"""
pass
[docs] def measure(self, v='', rf='', off=''):
"""
convert a measure to another reference
measure converts measures (epoch, direction etc.) from one reference to
another. It will, for instance, convert a direction from J2000 to AZEL
representation. \\
Its arguments are a measure, an output reference code (see the individual
measures for the allowable codes (direction,
position,
epoch,
frequency,
doppler,
radialvelocity,
baseline,
uvw,
earthmagnetic)), and an optional offset of
the same type as the main measure. The offset will be subtracted from the
result before it is returned.\\
In some cases (see the individual measures for when), more information than
just a reference code is necessary. E.g. the above example of a conversion to
AZEL, needs to know for when, and where on Earth we want it. This information
is stored in a reference frame. Measures are set in the reference frame with
the doframe function. The frame is tool
wide.\\
{\bf IMPORTANT NOTE:}\\
To get an accurate conversion of solar system objects direction to a celestial frame, one should convert to AZEL or HADEC before to get parallax accounted for. Thus if you want to get the moon's position in J2000..one would do it in 2 stages\\
i.e (after setting the appropriate frames) \\
moonazel=me.measure(me.direction('moon'), 'AZELGEO')
moonJ2000=me.measure(moonazel, 'J2000')
.. rubric:: Parameters
- ``v (record='')`` - measure to be converted
- ``rf (string='')`` - output reference code
- ``off (record='')`` - optional output offset measure
"""
pass
[docs] def doframe(self, v=''):
"""
save a measure as frame reference
doframe will set the measure specified as part of a frame.
If conversion from one type to another is necessary, with the
measure function,
the following frames
should be set if one of the reference types involved in the conversion is as
in the following lists.\\
{\em Epoch}
UTC
TAI
LAST position
LMST position
GMST1
GAST
UT1
UT2
TDT
TCG
TDB
TCD
{\em Direction}
J2000
JMEAN epoch
JTRUE epoch
APP epoch
B1950
BMEAN epoch
BTRUE epoch
GALACTIC
HADEC epoch position
AZEL epoch position
SUPERGALACTIC
ECLIPTIC
MECLIPTIC epoch
TECLIPTIC epoch
PLANET epoch [position]
{\em Position}
WGS84
ITRF
{\em Radial Velocity}
LSRK direction
LSRD direction
BARY direction
GEO direction epoch
TOPO direction epoch position
GALACTO direction
{\em Doppler}
RADIO
OPTICAL
Z
RATIO
RELATIVISTIC
BETA
GAMMA
{\em Frequency}
REST direction radialvelocity
LSRK direction
LSRD direction
BARY direction
GEO direction epoch
TOPO direction epoch position
GALACTO
.. rubric:: Parameters
- ``v (record='')`` - measure to be set in frame
"""
pass
[docs] def framenow(self):
"""
set the active frame time at now
framenow will fill the active frame time with the current date and time.
The different frame values necessary are described in the
doframe function
"""
pass
[docs] def showframe(self):
"""
show the currently active frame reference
showframe will display the currently active reference frame values on the
terminal. The
different frame values necessary are described in the
doframe function.
The frame is
displayed on the terminal using the formatting as done for the
show function.
"""
pass
[docs] def toradialvelocity(self, rf='', v0=''):
"""
convert a doppler type value to a real
radial velocity
toradialvelocity will convert a Doppler type value (e.g. in radio mode) to a
real radialvelocity. The type of velocity (e.g. LSRK) should be specified
.. rubric:: Parameters
- ``rf (string='')`` - radial velocity reference type
- ``v0 (record='')`` - doppler value measure
"""
pass
[docs] def tofrequency(self, rf='', v0='', rfq=''):
"""
convert a doppler type value to a frequency
tofrequency will convert a Doppler type value (e.g. in radio mode) to a
frequency. The type of frequency (e.g. LSRK) and a rest frequency (either as a
frequency quantity (e.g. qa.constants('HI')) or a frequency measure (e.g.
me.frequency('rest','5100MHz')) should be specified
.. rubric:: Parameters
- ``rf (string='')`` - frequency reference type
- ``v0 (record='')`` - doppler measure value
- ``rfq (record='')`` - rest frequency (frequency measure or freuency quantity)
"""
pass
[docs] def todoppler(self, rf='', v0='', rfq=''):
"""
convert a frequency or radialvelocity measure
to a doppler measure
todoppler will convert a radialvelocity measure or a frequency measure to a
doppler measure. In the case of a frequency, a rest frequency has to be
specified. The type of doppler wanted (e.g. RADIO) has to be specified.
.. rubric:: Parameters
- ``rf (string='')`` - doppler reference type
- ``v0 (record='')`` - radial velocity or frequency measure
- ``rfq (variant='')`` - rest frequency (frequency measure or frequency quantity)
"""
pass
[docs] def torestfrequency(self, v0='', d0=''):
"""
convert a frequency and doppler measure
to a rest frequency
torestfrequency will convert a frequency measure and a doppler measure
(e.g. obtained from another spectral line with a known rest frequency) to a
rest frequency.
.. rubric:: Parameters
- ``v0 (record='')`` - frequency reference type
- ``d0 (record='')`` - doppler measure value
"""
pass
[docs] def rise(self, crd='', ev='0.0deg'):
"""
get rise and set sidereal time
rise will give the rise/set hour-angles of a source. It needs the position
in the frame, and a time. If the latter is not set, the current time will be
used.
.. rubric:: Parameters
- ``crd (variant='')`` - direction of source (direction measure)
- ``ev (variant='0.0deg')`` - elevation angle limit
"""
pass
[docs] def riseset(self, crd='', ev='0.0deg'):
"""
get rise and set times
rise will give the rise/set times of a source. It needs the position
in the frame, and a time. If the latter is not set, the current time will be
used. The returned value is a record with a 'solved' field, which is F if the
source is always below or above the horizon. In that case the rise and set
fields will all have a string value. The record also returns a rise and set
record, with 'last' and 'utc' fields showing the rise and set times as epochs.
.. rubric:: Parameters
- ``crd (variant='')`` - direction of source (direction measure)
- ``ev (variant='0.0deg')`` - elevation limit
"""
pass
[docs] def posangle(self, m1='', m2=''):
"""
get position angle of two directions
posangle will give the position angle from a direction to another. I.e. the
angle in a direction between the direction to the North pole and the other
direction.
The posiation angle is calculated in the frame of the first argument. m2 is thus converted to the frame of m1 before calculating the position angle.
.. rubric:: Parameters
- ``m1 (record='')`` - direction of source (direction measure)
- ``m2 (record='')`` - direction of other source (direction measure)
"""
pass
[docs] def separation(self, m1='', m2=''):
"""
get separation angle between two directions
separation will give the separation of a direction from another as an angle.
.. rubric:: Parameters
- ``m1 (record='')`` - direction of source (direction measure)
- ``m2 (record='')`` - direction of other source (direction measure)
"""
pass
[docs] def addxvalue(self, a=''):
"""
get some additional measure information
addxvalue will give some additional information about some measures as a vector
of quantities. It is used internally to get the rectangular coordinates of
measures that are normally given in angles. The casual user will probably in
general not interested in this function.
.. rubric:: Parameters
- ``a (record='')`` - measures for which extra information is to be gotten
"""
pass
[docs] def type(self):
"""
type of tool
type will return the tool name.
"""
pass
[docs] def done(self):
"""
free resources used by tool.
In general you will not want to call this method. It removes and then
recreates the default measures tool.
"""
pass
[docs] def ismeasure(self, v=''):
"""
Check if measure
Checks if the operand is a correct measure
.. rubric:: Parameters
- ``v (record='')`` - value to be tested
"""
pass