|
casa
$Rev:20696$
|
|
casa
$Rev:20696$
|
Public Member Functions | |
| def | __init__ |
| def | advise |
| def | advisechansel |
| def | approximatepsf |
| def | boxmask |
| def | calcuvw |
| def | clean |
| def | clipimage |
| def | clipvis |
| def | close |
| def | defineimage |
| def | done |
| def | drawmask |
| def | exprmask |
| def | feather |
| def | filter |
| def | fitpsf |
| def | fixvis |
| def | ft |
| def | getweightgrid |
| def | linearmosaic |
| def | make |
| def | predictcomp |
| def | makeimage |
| def | makemodelfromsd |
| def | mask |
| def | mem |
| def | nnls |
| def | open |
| def | pb |
| def | plotsummary |
| def | plotuv |
| def | plotvis |
| def | plotweights |
| def | regionmask |
| def | regiontoimagemask |
| def | residual |
| def | restore |
| def | updateresidual |
| def | sensitivity |
| def | setbeam |
| def | selectvis |
| def | setjy |
| def | ssoflux |
| def | setmfcontrol |
| def | setoptions |
| def | setscales |
| def | setsmallscalebias |
| def | settaylorterms |
| def | setsdoptions |
| def | setvp |
| def | setweightgrid |
| def | smooth |
| def | stop |
| def | summary |
| def | uvrange |
| def | weight |
Public Attributes | |
| this | |
Static Private Attributes | |
| dictionary | __swig_setmethods__ |
| tuple | __setattr__ |
| dictionary | __swig_getmethods__ |
| tuple | __getattr__ |
| __repr__ | |
| __swig_destroy__ | |
| __del__ | |
| def __casac__.imager.imager.__init__ | ( | self | ) |
| def __casac__.imager.imager.advise | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
advise(self, takeadvice=True, amplitudeloss=0.05, fieldofview=initialize_variant("1.0deg"), _pixels=_pixels_advise,
_cell=_cell_advise, _facets=_facets_advise, _phasecenter=_phasecenter_advise) -> bool
Summary
Advise (and optionally use) parameter values
Input Parameters:
takeadvice Use the advised values? true
amplitudeloss Maximum fractional amplitude loss due to faceting 0.05
fieldofview Desired field of view 1.0deg
Output Parameters:
_pixels Number of pixels on a side
_cell Recommended maximum cellsize
_facets Recommended number of facets on one axis
_phasecenter Direction of phase center as a measure
--------------------------------------------------------------------------------| def __casac__.imager.imager.advisechansel | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
advisechansel(self, freqstart=1.0e6, freqend=1.1e6, freqstep=100.0, freqframe=string("LSRK"), msname=string(""),
fieldid=0, getfreqrange=False, spwselection=string("")) -> record *
Summary
Advise on spw and chan selection optimal for the image frequency range wanted
Input Parameters:
freqstart Begining of frequency range in Hz 1.0e6
freqend End of frequency range in Hz 1.1e6
freqstep spectral channel resolution of intended image in Hz 100.0
freqframe frame in which frequency is being expressed in other parameters LSRK
msname name of an ms, if empty string it will use the ms's used in selectvis
fieldid fieldid to use when msname is not empty otherwise ignored and field selected in selectvis is used 0
getfreqrange if set then freqrange is returned in the frame requested for the data selected false
spwselection if getfreqrange=True then this is needed to find the range of frequency in the frame requested
--------------------------------------------------------------------------------| def __casac__.imager.imager.approximatepsf | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
approximatepsf(self, psf=string(""), async=False) -> bool
Summary
Calculate approximate point spread functions
Input Parameters:
psf Name of output point spread function
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.boxmask | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
boxmask(self, mask=string(""), blc=initialize_vector(4,(int)0, (int)0, (int)0, (int)0), trc=std::vector< int >(),
value=1.0) -> bool
Summary
Construct a mask image from blc, trc
Input Parameters:
mask name of mask image
blc Bottom left corner 0 0 0 0
trc Top right corner, should be image shape
value Value to fill in 1.0
--------------------------------------------------------------------------------| def __casac__.imager.imager.calcuvw | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
calcuvw(self, fields=initialize_vector(1, (int)-1), refcode=string(""), reuse=True) -> bool
Summary
Calculates (u, v, w) coordinates for the ms.
Input Parameters:
fields Field IDs (numbered relative to 0) to operate on. Blank = all. -1
refcode Reference frame to use for the generated (u, v, w)s. WARNING: clean and the im tool ignore the reference frame claimed by the UVW column (it is often mislabelled as ITRF when it is really J2000) and instead assume the (u, v, w)s are in the same frame as the phase tracking center. calcuvw does not yet force the UVW column and field centers to use the same reference frame! Blank = use the phase tracking frame of vis.
reuse Start from the UVWs in vis (True) or calculate them from the antenna positions? true
--------------------------------------------------------------------------------| def __casac__.imager.imager.clean | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
clean(self, algorithm=string("clark"), niter=1000, gain=0.1, threshold=initialize_variant("0.0Jy"),
displayprogress=False, model=std::vector< string >(1, ""), keepfixed=initialize_vector(1, (bool)false),
complist=string(""), mask=std::vector< string >(1, ""),
image=std::vector< string >(1, ""), residual=std::vector< string >(1, ""),
psfimage=std::vector< string >(1, ""), interactive=False,
npercycle=100, masktemplate=string(""), async=False) -> record *
Summary
Calculate a deconvolved image with selected clean algorithm
Input Parameters:
algorithm Algorithm to use clark clarkstokes hogbom multiscale mfclark mfclarkstokes csclean csfast mfhogbom mfmultiscale wfclark wfhogbom clark
niter Number of Iterations, set to zero for no CLEANing 1000
gain Loop Gain for CLEANing 0.1
threshold Flux level at which to stop CLEANing 0.0Jy
displayprogress Display the progress of the cleaning? false
model Names of clean model images
keepfixed Keep one or more models fixed false
complist Name of component list
mask Names of mask images used for CLEANing
image Names of restored images
residual Names of residual images
psfimage Names of psfs if they are needed
interactive whether to stop clean and interactively mask false
npercycle If interactive is 'T', then no of iter of clean before stopping, usually a fraction of niter 100
masktemplate If non empty then will use this image to make the mask the first time
async Run asynchronously in the background? false
--------------------------------------------------------------------------------| def __casac__.imager.imager.clipimage | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
clipimage(self, image=string(""), threshold=initialize_variant("0.0Jy")) -> bool
Summary
Zero all pixels where Stokes I is below
a threshold
Input Parameters:
image name of image
threshold Threshold 0.0Jy
--------------------------------------------------------------------------------| def __casac__.imager.imager.clipvis | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
| def __casac__.imager.imager.close | ( | self | ) |
| def __casac__.imager.imager.defineimage | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
defineimage(self, nx=128, ny=-1, cellx=initialize_variant("1.0"), celly=initialize_variant(""), stokes=string("I"),
phasecenter=initialize_variant("0"), mode=string("mfs"), nchan=-1,
start=initialize_variant("0"), step=initialize_variant("1"), spw=initialize_vector(1, (int)0),
restfreq=initialize_variant(""), outframe=string("LSRK"),
veltype=string("radio"), facets=1, movingsource=initialize_variant(""),
distance=initialize_variant("0.0")) -> bool
Summary
Set the image parameters for subsequent processing
Input Parameters:
nx Total number of spatial pixels in x 128
ny Total number of spatial pixels in y -1
cellx Cellsize in x (e.g. '1arcsec') 1.0
celly Cellsize in y (e.g. '1arcsec')
stokes Stokes parameters to image (e.g. 'IQUV') IV IQU IQUV I
phasecenter Direction of phase center as a diretion measure or a field id 0
mode Type of processing (velocity =radiovelocity) frequency radiovelocity opticalvelocity truevelocity mfs
nchan Number of channels; a -1 (default) means all the channels as selected in selectvis and combined into one continuum channel -1
start Start channel; A 0-relative channel number of the spwid or a frequency quantity or a velocity quantity or radial velocity measure 0
step Step in channel; integer for number of channels or frequency quantity or velocity quantity or radial velocity measure 1
spw Spectral Window Id (0 relative) that defines center of image 0
restfreq rest frequency to use; default => use the one available in ms
outframe frequency frame of output image (default LSRK, '' => as input ms or LSRK in case of multiple ms's), options are LSRK, LSRD, BARY, GALACTO, LGROUP, CMB LSRK LSRK LSRD BARY GALACTO LGROUP CMB
veltype velocity definition ('radio' or 'optical' or 'relativistic') optical relativistic radio
facets Number of facets on each axis 1
movingsource Name of moving source, e.g planet or moon, to keep fixed in image
distance Distance to object: usually ignore this! (m) 0.0
--------------------------------------------------------------------------------| def __casac__.imager.imager.done | ( | self | ) |
| def __casac__.imager.imager.drawmask | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
drawmask(self, image=string(""), mask=string(""), niter=0, npercycle=0, threshold=string("0 mJy")) -> record *
Summary
Allows you do draw mask using the viewer
Input Parameters:
image name of template image
mask name of image to save mask in
niter Total number of iteration to display in box; just for display or python packaging 0
npercycle npercycle value to display in box; just for display or python packaging 0
threshold threshold to display in box ; just for display or python packaging 0 mJy
--------------------------------------------------------------------------------| def __casac__.imager.imager.exprmask | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
exprmask(self, mask=string(""), expr=1.0) -> bool
Summary
Construct a mask image from a LEL expression
Input Parameters:
mask name of mask image
expr Value to set the mask to. Any scalar or LEL expression 1.0
--------------------------------------------------------------------------------| def __casac__.imager.imager.feather | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
feather(self, image=string(""), highres=string(""), lowres=string(""), lowpsf=string(""), effdishdiam=-1.0,
showplot=False, async=False) -> bool
Summary
Feather together an interferometer and a single dish image
in the Fourier plane
Input Parameters:
image Name of output feathered image
highres Name of high resolution (interferometer) image
lowres Name of low resolution (single dish) image
lowpsf Name of optional low resolution point spread function
effdishdiam Optional new SD dish diameter in m to use in feathering; can be smaller than true dish size -1.0
showplot Plot the feather function false
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.filter | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
filter(self, type=string("gaussian"), bmaj=initialize_variant("1arcsec"), bmin=initialize_variant("1arcsec"),
bpa=initialize_variant("0deg"), async=False) -> bool
Summary
Apply additional weighting by filtering (u-v taper)
Input Parameters:
type Type of filtering or u-v tapering gaussian
bmaj Major axis of filter 1arcsec
bmin Minor axis of filter 1arcsec
bpa Position angle of filter 0deg
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.fitpsf | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
fitpsf(self, psf, async=False, _bmaj=_bmaj_fitpsf, _bmin=_bmin_fitpsf, _bpa=_bpa_fitpsf) -> bool Summary Fit the point spread function, making psf image first if needed Input Parameters: psf Name of input psf async Run asynchronously in the background false Output Parameters: _bmaj Major axis of beam _bmin Minor axis of beam _bpa Position angle of beam --------------------------------------------------------------------------------
| def __casac__.imager.imager.fixvis | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
fixvis(self, fields=initialize_vector(1, (int)-1), phasedirs=std::vector< string >(1, ""), refcode=string(""),
distances=initialize_vector(1, (double)0.0), datacolumn=string("all")) -> bool
Summary
Performs visibility adjustments.
Input Parameters:
fields Field IDs (numbered relative to 0) to operate on. Blank = all. -1
phasedirs Phase tracking centers for each field in fields, in the same order.
refcode Reference frame to use for the generated UVWs. WARNING: clean and the im tool ignore the reference frame claimed by the UVW column (it is often mislabelled as ITRF when it is really J2000) and instead assume the (u, v, w)s are in the same frame as the phase tracking center. calcuvw does not yet force the UVW column and field centers to use the same reference frame! Blank = use the phase tracking frame of vis.
distances A list of distances (in m) for the fields listed in fields. 0 = infinity. 0.0
datacolumn Which of DATA, MODEL_DATA, and/or CORRECTED_DATA to operate on. Default: 'all'. all
--------------------------------------------------------------------------------| def __casac__.imager.imager.ft | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
ft(self, model=std::vector< string >(1, ""), complist=string(""), incremental=False, async=False) -> bool
Summary
Fourier transform the specified model and componentlist
Input Parameters:
model Name of image
complist Name of component list
incremental Add to the existing MODEL\_DATA column? false
async Run asynchronously in the background? false
--------------------------------------------------------------------------------| def __casac__.imager.imager.getweightgrid | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
getweightgrid(self, type=string("imaging"), wgtimages=std::vector< string >(1, "")) -> variant *
Summary
get the requested weight grids
Input Parameters:
type Type of weight requested (imaging, ftweight) imaging imaging ftweight
wgtimages names of weightimages to save
--------------------------------------------------------------------------------| def __casac__.imager.imager.linearmosaic | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
linearmosaic(self, images=std::vector< string >(1, ""), mosaic=string(""), fluxscale=string(""), sensitivity=string(""),
fieldids=initialize_vector(1, (int)0), usedefaultvp=True,
vptable=string(""), async=False) -> bool
Summary
Make a linear mosaic of several images
Input Parameters:
images Input images to be mosaiced
mosaic Output mosaic image
fluxscale Fluxscale image
sensitivity Sensitivity image
fieldids List of field ids that correspond each of the images,used to center the PB of each image. (0-based list) 0
usedefaultvp Use the default vp type? true
vptable Voltage pattern table from the vpmanager for detailed specification
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.make | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
make(self, image=string(""), async=False) -> bool
Summary
Make an empty (i.e. blank) image
Input Parameters:
image name of output image
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.makeimage | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
makeimage(self, type=string("observed"), image=string(""), compleximage=string(""), verbose=True,
async=False) -> bool
Summary
Calculate images by gridding, etc.
Input Parameters:
type Type of output image observed
image Name of output image
compleximage Name of output complex image
verbose Report things like the center frequency to the logger true
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.makemodelfromsd | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
makemodelfromsd(self, sdimage=string(""), modelimage=string(""), sdpsf=string(""), maskimage=string("")) -> bool
Summary
Make an initial model image from a
Single Dish image
Input Parameters:
sdimage Single Dish image
modelimage Name of output image to be used as model
sdpsf PSF of Single Dish if needed
maskimage mask image
--------------------------------------------------------------------------------| def __casac__.imager.imager.mask | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
mask(self, image=string(""), mask=string(""), threshold=initialize_variant("0.0Jy"), async=False) -> bool
Summary
Construct a mask image by thresholding an image
Input Parameters:
image name of template image
mask name of mask image
threshold threshold for mask 0.0Jy
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.mem | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
mem(self, algorithm=string("entropy"), niter=20, sigma=initialize_variant("0.001Jy"), targetflux=initialize_variant("1.0Jy"),
constrainflux=False, displayprogress=False,
model=std::vector< string >(1, ""), keepfixed=initialize_vector(1, (bool)false),
complist=string(""), prior=std::vector< string >(1, ""), mask=std::vector< string >(1, ""),
image=std::vector< string >(1, ""), residual=std::vector< string >(1, ""),
async=False) -> bool
Summary
Calculate a deconvolved image with selected mem (maximum entropy) algorithm
Input Parameters:
algorithm Algorithm to use entropy emptiness mfentropy mfemptiness entropy entropy
niter Number of Iterations 20
sigma Image sigma to try to achieve 0.001Jy
targetflux Target flux for final image 1.0Jy
constrainflux Constrain image to match target flux? else targetflux used only to initialize model false
displayprogress Display the progress of the cleaning? false
model Names of model images
keepfixed Keep model fixed false
complist Name of component list
prior Names of mem prior images
mask Names of mask images (0=>no emission, 1=>emission permitted
image Names of restored images
residual Names of residual images
async Run asynchronously in the background? false
--------------------------------------------------------------------------------| def __casac__.imager.imager.nnls | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
nnls(self, model=std::vector< string >(1, ""), keepfixed=initialize_vector(1, (bool)false),
complist=string(""), niter=0, tolerance=1e-06, fluxmask=std::vector< string >(1, ""),
datamask=std::vector< string >(1, ""), image=std::vector< string >(1, ""),
residual=std::vector< string >(1, ""), async=False) -> bool
Summary
Calculate a deconvolved image using the
NNLS algorithm
Input Parameters:
model Name of image
keepfixed Keep model fixed false
complist Name of component list
niter Number of Iterations, set to zero for no NNLS 0
tolerance Tolerance for solution 1e-06
fluxmask Name of mask for allowed flux
datamask Name of mask for constraint pixels in dirty image
image Names of restored images
residual Names of restored images
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.open | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
open(self, thems=string(""), compress=False, usescratch=False) -> bool
Summary
Open a new MeasurementSet, for processing, closing current MeasurementSet
Input Parameters:
thems New MeasurementSet to be processed
compress Compress calibration columns? false
usescratch If true: Imager will use corrected data column and make scratch columns of they donot exist false
--------------------------------------------------------------------------------| def __casac__.imager.imager.pb | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
pb(self, inimage=string(""), outimage=string(""), incomps=string(""), outcomps=string(""),
operation=string("apply"), pointingcenter=string("N. pole"), parangle=initialize_variant("0.0deg"),
pborvp=string("pb"), async=False) -> bool
Summary
Applies or corrects for a primary beam
Input Parameters:
inimage Input image to apply beam to
outimage Output image after beam is applied
incomps Input Componentlist table name
outcomps Output Componentlist table name
operation Operation correct apply
pointingcenter Pointing center for primary beam application false N. pole
parangle Parallactic angle for calculation 0.0deg
pborvp Primary Beam or Voltage Pattern vb pb
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.plotsummary | ( | self | ) |
| def __casac__.imager.imager.plotuv | ( | self, | |
rotate = False |
|||
| ) |
| def __casac__.imager.imager.plotvis | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
plotvis(self, type=string("all"), increment=1) -> bool
Summary
Plot the visibility amplitudes as a function of u-v radius (also, see visplot tool
Input Parameters:
type Type of plot: can contain all, observed, corrected, model, residual all observed corrected model residual all
increment Increment in points to plot 1
--------------------------------------------------------------------------------| def __casac__.imager.imager.plotweights | ( | self, | |
gridded = False, |
|||
increment = 1 |
|||
| ) |
plotweights(self, gridded=False, increment=1) -> bool Summary Plot the visibility weights as a function of u-v radius Input Parameters: gridded Do gridded plot? false increment Increment in points to plot 1 --------------------------------------------------------------------------------
| def __casac__.imager.imager.predictcomp | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
predictcomp(self, objname=string(""), standard=string(""), epoch=initialize_variant("55555.0d"), freqs=initialize_vector(1,(double)1.0e11),
pfx=string("predictcomp")) -> string
Summary
Make a component list for a known object
Input Parameters:
objname Name of the object
standard Name of the flux standard
epoch Time to use, as an epoch measure, e.g. me.epoch('UTC', '55555d'), for Solar System objects 55555.0d epoch measure
freqs The frequencies to use, in Hz 1.0e11
pfx Prefix for the name of the component list predictcomp
--------------------------------------------------------------------------------| def __casac__.imager.imager.regionmask | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
regionmask(self, mask=string(""), region=initialize_record(""), boxes=initialize_variant(""), circles=initialize_variant(""),
value=1.0) -> bool
Summary
Construct a mask image from a region
Input Parameters:
mask name of mask image
region Region record usually from regionmanager unset
boxes list of 4 elements lists e.g [[xblc1, yblc1, xtrc1, ytrc1], [[xblc2, yblc2, xtrc2, ytrc2]]
circles list of 3 elements lists e.g [[rad0, xcen0, ycen0], [rad1,xcen1, ycen1], .....]
value Value to set the mask to 1.0
--------------------------------------------------------------------------------| def __casac__.imager.imager.regiontoimagemask | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
regiontoimagemask(self, mask=string(""), region=initialize_record(""), boxes=initialize_variant(""), circles=initialize_variant(""),
value=1.0) -> bool
Summary
union a mask image with various regions
Input Parameters:
mask name of mask image
region Region record usually from regionmanager unset
boxes list of 4 elements lists e.g [[xblc1, yblc1, xtrc1, ytrc1], [[xblc2, yblc2, xtrc2, ytrc2]]
circles list of 3 elements lists e.g [[rad0, xcen0, ycen0], [rad1,xcen1, ycen1], .....]
value Value to set the mask to 1.0
--------------------------------------------------------------------------------| def __casac__.imager.imager.residual | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
residual(self, model=std::vector< string >(1, ""), complist=string(""), image=std::vector< string >(1, ""),
async=False) -> bool
Summary
Calculate the residual image with respect to current model and component list
Input Parameters:
model Names of input models
complist Name of component list
image Names of output residual images
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.restore | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
restore(self, model=std::vector< string >(1, ""), complist=string(""), image=std::vector< string >(1, ""),
residual=std::vector< string >(1, ""), async=False) -> bool
Summary
Calculate the restored image with restored model, component list, and residuals
Input Parameters:
model Names of input model
complist Name of component list
image Names of output restored images
residual Names of residual images
async Run asynchronously in the background false
--------------------------------------------------------------------------------Definition at line 831 of file imager.py.
Referenced by sdutil.scantable_restore_impl.__del__().
| def __casac__.imager.imager.selectvis | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
selectvis(self, vis=string(""), nchan=initialize_vector(1, (int)-1), start=initialize_vector(1, (int)0),
step=initialize_vector(1, (int)1), spw=initialize_variant("-1"), field=initialize_variant("-1"),
baseline=initialize_variant("-1"), time=initialize_variant(""),
scan=initialize_variant(""), observation=initialize_variant(""),
uvrange=initialize_variant(""), taql=string(""), usescratch=False,
datainmemory=False, writeaccess=True) -> bool
Summary
Select visibilities for subsequent processing
Input Parameters:
vis Measurementset for which this selection applies; an empty string '' implies that it is to be applied in ms used in open
nchan Number of channels to select -1
start Start channels (0-relative) 0
step Step in channel number 1
spw Spectral Window Ids (0 relative) to select; -1 interpreted as all -1
field Field Ids (0 relative) or Field names (msselection syntax and wilcards are used) to select -1
baseline Antenna Ids (0 relative) or Antenna names (msselection syntax and wilcards are used) to select -1
time Limit data selected to be within a given time range. The syntax is defined in the msselection link
scan Limit data selected on scan numbers. The syntax is defined in the msselection link
observation Limit data using observation IDs. The syntax is defined in the msselection link
uvrange Limit data selected on uv distance. The syntax is defined in the msselection link
taql For the TAQL experts, flexible data selection using the TAQL syntax
usescratch If True: imager will use CORRECTED_DATA column and will make scratch columns and store Model visibilities after deconvolution false
datainmemory If True: imager will load the selected ms memory; useful if imaging a few channels that fit in memory false
writeaccess If False: imager will open the ms in readmode; useful for multiple process access to the MS true
--------------------------------------------------------------------------------| def __casac__.imager.imager.sensitivity | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
sensitivity(self, async=False, _pointsource=_pointsource_sensitivity, _relative=_relative_sensitivity,
_sumweights=_sumweights_sensitivity) -> bool
Summary
Calculate rms sensitivity
Input Parameters:
async Run asynchronously in the background false
Output Parameters:
_pointsource Calculated point source sensitivity (Jy/beam)
_relative Calculated relative sensitivity
_sumweights Calculated sum of weights
--------------------------------------------------------------------------------| def __casac__.imager.imager.setbeam | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setbeam(self, bmaj=initialize_variant("1.0arcsec"), bmin=initialize_variant("1.0arcsec"), bpa=initialize_variant("0deg"),
async=False) -> bool
Summary
Set the beam parameters for clean restoration
Input Parameters:
bmaj Major axis of beam 1.0arcsec
bmin Minor axis of beam 1.0arcsec
bpa Position angle of beam 0deg
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.setjy | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setjy(self, field=initialize_variant(""), spw=initialize_variant(""), modimage=string(""), fluxdensity=initialize_vector(4,(double)0.0, (double)0.0, (double)0.0, (double)0.0),
standard=string("SOURCE"),
scalebychan=False, spix=0.0, reffreq=initialize_variant("1GHz"),
time=string(""), scan=string(""), observation=string("")) -> bool
Summary
Compute the model visibility for a specified source flux density
Input Parameters:
field Field Id (0-relative) or name
spw Spectral Window Id. (0-relative)
modimage A model image
fluxdensity Specified flux density (I,Q,U,V) in Jy (lookup the value; use 1.0 if not found) 0.0 0.0 0.0 0.0
standard Flux density standard Baars Perley 90 Perley-Taylor 95 Perley-Taylor 99 Perley-Butler 2010 SOURCE
scalebychan Do the flux scaling on a per channel basis else on a spw basis. Effectively True if fluxdensity is specified. false
spix Spectral index for fluxdensity. S = fluxdensity * (freq/reffreq)**spix 0.0
reffreq Reference frequency for spix. 1GHz
time Time range to operate on
scan Scan(s) to operate on
observation Observation ID(s) to operate on
--------------------------------------------------------------------------------| def __casac__.imager.imager.setmfcontrol | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setmfcontrol(self, cyclefactor=1.5, cyclespeedup=-1, cyclemaxpsffraction=0.8, stoplargenegatives=2,
stoppointmode=-1, minpb=0.1, scaletype=string("NONE"), constpb=0.4, fluxscale=std::vector< string >(1, ""),
flatnoise=True) -> bool
Summary
Set various cycle control parameters for
multi-field and wide-field imageing.
Input Parameters:
cyclefactor Cycle threshold = max_resid * min(cyclemaxpsffraction, this * max_sidelobe) 1.5
cyclespeedup Cycle threshold doubles in this number of iterations -1
cyclemaxpsffraction Cycle threshold = max_resid * min(this, cyclefactor * max_sidelobe) 0.8
stoplargenegatives Stop the multiscale cycle for the first n cycles when a negative comp is found on the largest scale 2
stoppointmode Stop multiscale altogether if the smallest scale recieves this many consecutive components -1
minpb Minimum PB level to use 0.1
scaletype Image plane flux scale type SAULT NONE NONE
constpb In Sault weighting the flux scale is constant above this PB level 0.4
fluxscale Names of flux scale images for mosaicing
flatnoise Set to false if clean component search is to be done in an optimal signal/noise residual image if true will clean in a constant noise image true
--------------------------------------------------------------------------------| def __casac__.imager.imager.setoptions | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setoptions(self, ftmachine=string("ft"), cache=-1, tile=16, gridfunction=string("SF"), location=initialize_variant(""),
padding=1.0, freqinterp=string("nearest"), wprojplanes=1,
epjtablename=string(""), applypointingoffsets=False, dopbgriddingcorrections=True,
cfcachedirname=string(""), pastep=1.0, pblimit=0.05, imagetilevol=0,
singleprecisiononly=False, numthreads=-1, psterm=True, aterm=True, wbawp=False) -> bool
Summary
Set some general options for subsequent processing
Input Parameters:
ftmachine Fourier transform machine ft ft sd both wproject mosaic
cache Size of gridding cache in complex pixels; default use half the memory available on computer -1
tile Size of a gridding tile in pixels (in 1 dimension) 16
gridfunction Gridding function SF SF BOX PB GAUSS GJINC
location Location used in phase rotations
padding Padding factor in image plane (>=1.0) 1.0
freqinterp interpolation mode in frequency;options:- nearest, linear, cubic, spline nearest nearest linear cubic spline
wprojplanes No of gridding convolution functions used in wproject-ft machine 1
epjtablename E-Jones table name. This is used if applypointingoffsets is set to True.
applypointingoffsets Apply pointing offset corrections during deconvolution. false
dopbgriddingcorrections Correct for PB gridding before prediction of visibilities. This should be True when doing deconvolution. This should be False when predicting visibilities for model sky with no primary beam attenuation in the model. true
cfcachedirname Directory where convolution functions are to be (or are being ) cached on the disk.
pastep The number of steps in Parallactic Angle used to compute the average power pattern. Since a linear interpolation is used to interpolate convolution functions during gridding, this can be different from PA increment to compute new convolution functions. This parameter is however not used yet. 1.0
pblimit Primary beam limit when using PBWProjection 0.05
imagetilevol Tile size on for image on disk (in pixel, multiply by 4 to get the byte size). It is safe to leave this as default, meant for usage on filesystem like Lustre, the default implies 32x32x4x32 tile shape 0
singleprecisiononly Set this value to True to force single precision all the time. Otherwise imager may use double precision gridding (ft and wproject only for now) when it can and deems it fit. Setting to True can be handy on low memory machines false
numthreads Limit the number of threads used in this run (openmp enabled only) -1
psterm Switch-on the PS-Term? true
aterm Switch-on the A-Term? true
wbawp Trigger the WB A-Projection algorithm? false
--------------------------------------------------------------------------------| def __casac__.imager.imager.setscales | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setscales(self, scalemethod=string("nscales"), nscales=5, uservector=initialize_vector(3,(double)0.0, (double)3.0, (double)10.0)) -> bool
Summary
Set the scale sizes for MultiScale Clean
Input Parameters:
scalemethod Method by which scales are set nscales uservector nscales
nscales Number of scales 5
uservector Vector of scale sizes in pixels to use, defaults should be 0,3,10 0.0 3.0 10.0
--------------------------------------------------------------------------------| def __casac__.imager.imager.setsdoptions | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setsdoptions(self, scale=1.0, weight=1.0, convsupport=-1, pointingcolumntouse=string("DIRECTION"), truncate=initialize_variant("-1pixel"),
gwidth=initialize_variant("-1pixel"),
jwidth=initialize_variant("-1pixel")) -> bool
Summary
Set some options for single dish processing
Input Parameters:
scale Scaling applied to single dish data 1.0
weight Weights applied to single dish data 1.0
convsupport number of pixel for convolution support -1
pointingcolumntouse Which Pointing Table column to use to get direction DIRECTION DIRECTION TARGET ENCODER POINTING_OFFSET SOURCE_OFFSET
truncate truncation radius (effective only for 'GAUSS' or 'GJINC') -1pixel
gwidth radius of half maximum for gaussian (effective only for 'GAUSS' or 'GJINC') -1pixel
jwidth c-parameter for jinc function (effective only for 'GJINC') -1pixel
--------------------------------------------------------------------------------| def __casac__.imager.imager.setsmallscalebias | ( | self, | |
inbias = 0.6 |
|||
| ) |
| def __casac__.imager.imager.settaylorterms | ( | self, | |
ntaylorterms = 2, |
|||
reffreq = 0.0 |
|||
| ) |
settaylorterms(self, ntaylorterms=2, reffreq=0.0) -> bool Summary Set the number of Taylor series terms for Multi-Frequency Clean Input Parameters: ntaylorterms Number of Taylor terms 2 reffreq Reference Frequency 0.0 --------------------------------------------------------------------------------
| def __casac__.imager.imager.setvp | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setvp(self, dovp=False, usedefaultvp=True, vptable=string(""), dosquint=False, parangleinc=initialize_variant("360deg"),
skyposthreshold=initialize_variant("180deg"), telescope=string(""),
verbose=True) -> bool
Summary
Set the voltage pattern model for subsequent processing
Input Parameters:
dovp Do voltage pattern (ie, primary beam) correction false
usedefaultvp Look up the default VP for this telescope and frequency? true
vptable If usedefaultvp is False, provide a VP Table made with vpmanager
dosquint Activate the beam squint in the VP model false
parangleinc Parallactice angle increment for squint application 360deg
skyposthreshold Sky position threshold 180deg
telescope Which default telescope to use; if empty use the one in encoded in MS
verbose If false, suppress some messages from being sent to the logger. true
--------------------------------------------------------------------------------| def __casac__.imager.imager.setweightgrid | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
setweightgrid(self, weight=initialize_variant(""), type=string("imaging")) -> bool
Summary
set the requested weight grids
Input Parameters:
weight Numeric array. Required input.
type Type of weight requested imaging
--------------------------------------------------------------------------------| def __casac__.imager.imager.smooth | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
smooth(self, model=std::vector< string >(1, ""), image=std::vector< string >(1, ""), usefit=True,
bmaj=initialize_variant("5.arcsec"), bmin=initialize_variant("5.arcsec"),
bpa=initialize_variant("0deg"), normalize=True, async=False) -> bool
Summary
Calculate an image smoothed with a Gaussian beam
Input Parameters:
model Name of input model
image Name of output smoothed images
usefit Use the fitted value (rather than that specified true
bmaj Major axis of beam 5.arcsec
bmin Minor axis of beam 5.arcsec
bpa Position angle of beam 0deg
normalize Normalize volume of psf to unity true
async Run asynchronously in the background false
--------------------------------------------------------------------------------| def __casac__.imager.imager.ssoflux | ( | self | ) |
| def __casac__.imager.imager.stop | ( | self | ) |
| def __casac__.imager.imager.summary | ( | self | ) |
| def __casac__.imager.imager.updateresidual | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
updateresidual(self, model=std::vector< string >(1, ""), complist=string(""), image=std::vector< string >(1, ""),
residual=std::vector< string >(1, "")) -> bool
Summary
Calculate the residual and restored images with new modified model, component list,
Input Parameters:
model Names of input model
complist Name of component list
image Names of output restored images
residual Names of residual images
--------------------------------------------------------------------------------| def __casac__.imager.imager.uvrange | ( | self, | |
uvmin = 0.0, |
|||
uvmax = 0.0 |
|||
| ) |
uvrange(self, uvmin=0.0, uvmax=0.0) -> bool Summary Select data within the limit of a given range Input Parameters: uvmin Minimum uv distance allowed (wavelengths) 0.0 uvmax Maximum uv distance allowed (wavelengths) 0.0 --------------------------------------------------------------------------------
| def __casac__.imager.imager.weight | ( | self, | |
| args, | |||
| kwargs | |||
| ) |
weight(self, type=string("natural"), rmode=string("none"), noise=initialize_variant("0.0Jy"),
robust=0.0, fieldofview=initialize_variant("0.0arcsec"), npixels=0, mosaic=False,
async=False) -> bool
Summary
Apply additional weighting to the visibility weights
Input Parameters:
type Type of weighting uniform natural briggs radial natural
rmode Mode of briggs weighting norm abs none
noise Noise used in absolute briggs weighting 0.0Jy
robust Parameter in briggs weighting 0.0
fieldofview Field of view for uniform weighting 0.0arcsec
npixels Number of pixels in the u and v directions 0
mosaic Individually weight the fields of a mosaic false
async Run asynchronously in the background false
--------------------------------------------------------------------------------Definition at line 1222 of file imager.py.
Referenced by task_sdgrid.sdgrid_worker.execute().
__casac__.imager.imager.__del__ [static, private] |
tuple __casac__.imager.imager.__getattr__ [static, private] |
__casac__.imager.imager.__repr__ [static, private] |
tuple __casac__.imager.imager.__setattr__ [static, private] |
__casac__.imager.imager.__swig_destroy__ [static, private] |
dictionary __casac__.imager.imager.__swig_getmethods__ [static, private] |
dictionary __casac__.imager.imager.__swig_setmethods__ [static, private] |
1.8.0