s_optimise

Module Contents

Classes

intList	Information about how to convert command line strings to Python objects.
Timer
pafmap

Functions

arg_init()	Define the interpretation of command line arguments.
bsect(x, z)
fit_parabola(x, y)	Fit a parabola to three points
fit_parabola(x, y)	Fit a parabola to three points
airy(x)
airy1d(xgrid, xc[, wid])
airy2d(xgrid, xc, yc[, wid])
gauss1d(M, dxy, xc[, wid])
gauss2d(xgrid, xc, yc[, wid])
empiricalFWHM(freq)
getGrid(M, w)
makeBeams(xgrid, offsets, fwhm)
calcCov(abeams)
get_cross_sep(offsets)
corr_func(x)
cv_modelled(offsets, fwhm)
polyval2d(x, y, m)
fnc(x, a, e)
designMat_2(X, Y, b)
apodizePAF(xgrid[, centre, posang, unit, fov_method])
apodizePAF_old(xgrid[, centre, posang, unit])
apodizePAF_new(xgrid[, centre, posang, unit, from_image])
draw_apod(fov_meth[, levels, grid_hwid])
make_paf_map(cov, beams[, sefds])	Generate a sensitivity map over the PAF field of view
makeCircle(rad, x0, y0)
drawFootprint(fp, beamWid, gridHWid[, labels])
draw_footprint_il(fp, beam_wid, grid_hwid[, labels])
ASKAP_SEFD(freq)
ASKAP_tsys_on_eff(freq)
subXaxis(ax1, scale, label)
find_best_pitch(fpname, freq, fov_meth)
get_eq_area(fpname, pitch, freq, xg, fov_meth)
estimate_pitch(fpname, freq)
calcSummary(fpname, freq, fov_meth, **kw)
plotFootprint(pmap, fpname, fp, best_pitch, fov_m)
plot_opt(suffix)
plot_pitch_tuning(suffix)
main()

Attributes

aces_cfg
fp_factory
HELP_START
explanation
announce
fp_choices
root2

s_optimise.aces_cfg

s_optimise.fp_factory

s_optimise.HELP_START = Multiline-String

Show Value

"""This estimates the ASKAP survey speed for an optimum setting of the beam separation.
It does this for any available footprint, and gives results as a function of frequency.
The results are saved into python pickle files and used to construct some summary plots.
The -p option will do the plotting without re-doing the time-consuming optimising calculations.

The Fov_method options (chosen with '-m') are:
  sefd  USe recent SEFD measures across footprint
  image Use recent estimates from image noise across mosaic
  old   Use the original measurement made with BETA (Mark I PAF)

V 2April2019
"""

s_optimise.explanation

s_optimise.announce = Multiline-String

Show Value

"""
s_optimise.py
"""

s_optimise.fp_choices

s_optimise.arg_init()

Define the interpretation of command line arguments.

class s_optimise.intList(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Bases: argparse.Action

Information about how to convert command line strings to Python objects.

Action objects are used by an ArgumentParser to represent the information needed to parse a single argument from one or more strings from the command line. The keyword arguments to the Action constructor are also all attributes of Action instances.

Keyword Arguments:

• option_strings – A list of command-line option strings which

  should be associated with this action.

• dest – The name of the attribute to hold the created object(s)

• nargs – The number of command-line arguments that should be

  consumed. By default, one argument will be consumed and a single value will be produced. Other values include:

  • N (an integer) consumes N arguments (and produces a list)

  • ‘?’ consumes zero or one arguments

  • ‘*’ consumes zero or more arguments (and produces a list)

  • ‘+’ consumes one or more arguments (and produces a list)

  Note that the difference between the default and nargs=1 is that with the default, a single value will be produced, while with nargs=1, a list containing a single value will be produced.

• const – The value to be produced if the option is specified and the

  option uses an action that takes no values.

• default – The value to be produced if the option is not specified.

• type – A callable that accepts a single string argument, and

  returns the converted value. The standard Python types str, int, float, and complex are useful examples of such callables. If None, str is used.

• choices – A container of values that should be allowed. If not None,

  after a command-line argument has been converted to the appropriate type, an exception will be raised if it is not a member of this collection.

• required – True if the action must always be specified at the

  command line. This is only meaningful for optional command-line arguments.

• help – The help string describing the argument.

• metavar – The name to be used for the option’s argument with the

  help string. If None, the ‘dest’ value will be used as the name.

__call__(parser, namespace, values, option_string=None)

s_optimise.bsect(x, z)

class s_optimise.Timer

reset()

getTotal()

getDelta()

s_optimise.root2

s_optimise.fit_parabola(x, y)

Fit a parabola to three points :param x: the three abscissae :param y: the three ordinates :return: the coefficients of x**0, x**1, x**2

s_optimise.fit_parabola(x, y)

Fit a parabola to the given points. If len(x) == 3, find the unique coefficients; otherwise perform a least-squares fit. :param x: the three abscissae :param y: the three ordinates :return: the coefficients of x**0, x**1, x**2

s_optimise.airy(x)

s_optimise.airy1d(xgrid, xc, wid=1.0)

s_optimise.airy2d(xgrid, xc, yc, wid=1.0)

s_optimise.gauss1d(M, dxy, xc, wid=1.0)

s_optimise.gauss2d(xgrid, xc, yc, wid=1.0)

s_optimise.empiricalFWHM(freq)

s_optimise.getGrid(M, w)

s_optimise.makeBeams(xgrid, offsets, fwhm)

s_optimise.calcCov(abeams)

s_optimise.get_cross_sep(offsets)

s_optimise.corr_func(x)

s_optimise.cv_modelled(offsets, fwhm)

s_optimise.polyval2d(x, y, m)

s_optimise.fnc(x, a, e)

s_optimise.designMat_2(X, Y, b)

s_optimise.apodizePAF(xgrid, centre=None, posang=0.0, unit=False, fov_method='sefd')

s_optimise.apodizePAF_old(xgrid, centre=None, posang=0.0, unit=False)

s_optimise.apodizePAF_new(xgrid, centre=None, posang=0.0, unit=False, from_image=True)

s_optimise.draw_apod(fov_meth, levels=None, grid_hwid=3.0)

s_optimise.make_paf_map(cov, beams, sefds=None)

Generate a sensitivity map over the PAF field of view :param cov: the normalised covariance matrix (computed from model beam weights in calCov) :param beams: the power response of each beam on an MxM grid; shape = (Nb, M, M) :param sefds: If defined, is an array of measured SEFD values (in Jy) in beam order. :return: s: the variance across the smae grid defined in beams.

class s_optimise.pafmap(freq, xgrid, pitch)

Bases: object

addmap(var, offsets)

makeLinMos()

getRipple()

getSS(sigma=0.0001, BW=288000000.0, Na=36, npol=2)

get_survey_params()

getContArea()

_calcCentroid(var)

static _findPeak(var)

Parameters:

var –

Returns:

s_optimise.makeCircle(rad, x0, y0)

s_optimise.drawFootprint(fp, beamWid, gridHWid, labels=None)

s_optimise.draw_footprint_il(fp, beam_wid, grid_hwid, labels=None)

s_optimise.ASKAP_SEFD(freq)

s_optimise.ASKAP_tsys_on_eff(freq)

s_optimise.subXaxis(ax1, scale, label)

s_optimise.find_best_pitch(fpname, freq, fov_meth)

s_optimise.get_eq_area(fpname, pitch, freq, xg, fov_meth)

s_optimise.estimate_pitch(fpname, freq)

s_optimise.calcSummary(fpname, freq, fov_meth, **kw)

s_optimise.plotFootprint(pmap, fpname, fp, best_pitch, fov_m)

s_optimise.plot_opt(suffix)

s_optimise.plot_pitch_tuning(suffix)

s_optimise.main()