Coverage for /wheeldirectory/casa-6.7.0-12-py3.10.el8/lib/py/lib/python3.10/site-packages/casatools/__casac__/imager.py: 68%

263 statements  

« prev     ^ index     » next       coverage.py v7.6.4, created at 2024-11-01 07:19 +0000

1# This file was automatically generated by SWIG (http://www.swig.org). 

2# Version 3.0.12 

3# 

4# Do not make changes to this file unless you know what you are doing--modify 

5# the SWIG interface file instead. 

6 

7from sys import version_info as _swig_python_version_info 

8if _swig_python_version_info >= (2, 7, 0): 

9 def swig_import_helper(): 

10 import importlib 

11 pkg = __name__.rpartition('.')[0] 

12 mname = '.'.join((pkg, '_imager')).lstrip('.') 

13 try: 

14 return importlib.import_module(mname) 

15 except ImportError: 

16 return importlib.import_module('_imager') 

17 _imager = swig_import_helper() 

18 del swig_import_helper 

19elif _swig_python_version_info >= (2, 6, 0): 

20 def swig_import_helper(): 

21 from os.path import dirname 

22 import imp 

23 fp = None 

24 try: 

25 fp, pathname, description = imp.find_module('_imager', [dirname(__file__)]) 

26 except ImportError: 

27 import _imager 

28 return _imager 

29 try: 

30 _mod = imp.load_module('_imager', fp, pathname, description) 

31 finally: 

32 if fp is not None: 

33 fp.close() 

34 return _mod 

35 _imager = swig_import_helper() 

36 del swig_import_helper 

37else: 

38 import _imager 

39del _swig_python_version_info 

40 

41try: 

42 _swig_property = property 

43except NameError: 

44 pass # Python < 2.2 doesn't have 'property'. 

45 

46try: 

47 import builtins as __builtin__ 

48except ImportError: 

49 import __builtin__ 

50 

51def _swig_setattr_nondynamic(self, class_type, name, value, static=1): 

52 if (name == "thisown"): 

53 return self.this.own(value) 

54 if (name == "this"): 

55 if type(value).__name__ == 'SwigPyObject': 

56 self.__dict__[name] = value 

57 return 

58 method = class_type.__swig_setmethods__.get(name, None) 

59 if method: 

60 return method(self, value) 

61 if (not static): 

62 if _newclass: 

63 object.__setattr__(self, name, value) 

64 else: 

65 self.__dict__[name] = value 

66 else: 

67 raise AttributeError("You cannot add attributes to %s" % self) 

68 

69 

70def _swig_setattr(self, class_type, name, value): 

71 return _swig_setattr_nondynamic(self, class_type, name, value, 0) 

72 

73 

74def _swig_getattr(self, class_type, name): 

75 if (name == "thisown"): 

76 return self.this.own() 

77 method = class_type.__swig_getmethods__.get(name, None) 

78 if method: 

79 return method(self) 

80 raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) 

81 

82 

83def _swig_repr(self): 

84 try: 

85 strthis = "proxy of " + self.this.__repr__() 

86 except __builtin__.Exception: 

87 strthis = "" 

88 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 

89 

90try: 

91 _object = object 

92 _newclass = 1 

93except __builtin__.Exception: 

94 class _object: 

95 pass 

96 _newclass = 0 

97 

98class imager(_object): 

99 """Proxy of C++ casac::imager class.""" 

100 

101 __swig_setmethods__ = {} 

102 __setattr__ = lambda self, name, value: _swig_setattr(self, imager, name, value) 

103 __swig_getmethods__ = {} 

104 __getattr__ = lambda self, name: _swig_getattr(self, imager, name) 

105 __repr__ = _swig_repr 

106 

107 def __init__(self): 

108 """__init__(self) -> imager""" 

109 this = _imager.new_imager() 

110 try: 

111 self.this.append(this) 

112 except __builtin__.Exception: 

113 self.this = this 

114 

115 def advise(self, *args, **kwargs): 

116 """ 

117 advise(self, _takeadvice, _amplitudeloss, _fieldofview, _pixels, _cell, _facets, _phasecenter) -> bool 

118 

119 

120 

121 Summary: 

122 Advise (and optionally use) parameter values 

123 

124 Description: 

125 

126 

127 Advise on recommended values of certain parameters. Return these 

128 values and optionally use them in Imager. 

129 

130 The calculations are performed as following: 

131 

132 begin{description} 

133 item[cell] The maximum uv distance in wavelength is found and then half of the 

134 inverse is taken as the maximum cellsize allowed. 

135 item[pixels] The field of view is converted to a number of pixels 

136 using the calculated cell size. 

137 item[facets] The number of facets on an axis is calculated in two 

138 different ways. The first method simply requires that the peeling of 

139 facets away from the celestial sphere should not cause an amplitude 

140 drop of more than the argument {tt amplitudeloss}. The positions may 

141 be incorrect, but all the sources will be removed correctly. The 

142 second method requires that the source positions be accurate to the 

143 same fraction of the beam specified by {tt amplitudeloss}. The 

144 second calculates the second moment in w and in uv distance and 

145 chooses the number of facets correspondingly. The first method does 

146 the same but after fitting a plane to the sampling: $w = a u + b v$. 

147 For an approximately coplanar array, the positions may be wrong but 

148 the removal of sidelobes will be accurate. The number of facets 

149 returned is the second, usually smaller, number. The formula used 

150 is: 

151 begin{equation} 

152 N_{facets} = N_{pixels} sqrt{{{Delta theta}over{sqrt{8 delta A}}}{w_{rms}}over{uv_{rms}}} 

153 end{equation} 

154 where $Delta theta$ is the cellsize in radians, and $delta A$ is 

155 the amplitude loss. This formula can be derived from (a) the peeling 

156 of facets from the celestial sphere, and (b) a quadratic approximation 

157 for the beam size both in the plane of the sky and along the $w$ axis. 

158 end{description} 

159 

160 Input Parameters: 

161 takeadvice Use the advised values? 

162 amplitudeloss Maximum fractional amplitude loss due to faceting 

163 fieldofview Desired field of view 

164 

165 Output Parameters: 

166 pixels Number of pixels on a side 

167 cell Recommended maximum cellsize 

168 facets Recommended number of facets on one axis 

169 phasecenter Direction of phase center as a measure 

170 

171 -------------------------------------------------------------------------------- 

172 

173 """ 

174 return _imager.imager_advise(self, *args, **kwargs) 

175 

176 

177 def advisechansel(self, *args, **kwargs): 

178 """ 

179 advisechansel(self, _freqstart, _freqend, _freqstep, _freqframe, _msname, _fieldid, _getfreqrange, _spwselection) -> record * 

180 

181 

182 

183 Summary: 

184 Advise on spw and chan selection optimal for the image frequency range wanted 

185 

186 Description: 

187 

188 

189 Basically tells you what channels of which spectral window need to be 

190 selected for your image spectral parameters. The freqstep is used to 

191 calulate the extra padding needed for data selection at the begining 

192 and end of the range. The freqframe parameter is the frame in which 

193 the frequency range is being given. It will be converted to the frame 

194 of the data with time to locate which channel match. 

195 A record will be returned with an element for each ms used in selectvis. 

196 Each element of the record will have the spwids and channel start and nchan for each spwid. 

197 if the parameter msname is used then the MSs associated associated with 

198 this tool (that have been either 'open'ed or 'selectvis'ed) are ignored 

199 In this mode it is a helper function to the general world ...no need to 

200 open or selectvis. You need to specify the field_id for which this calculation is 

201 being done for in the helper mode. 

202 If you have already set MS's and selected data and msname='' then 

203 the calulation is done for the field(s) selected in selectvis. 

204 

205 If the parameter {tt getfreqrange=True} then the reverse is requested. You set {tt spwselection} to be the range of data selection you want to use and you'll get the range of frequency covered in the frame you set. 

206 

207 Input Parameters: 

208 freqstart Begining of frequency range in Hz 

209 freqend End of frequency range in Hz 

210 freqstep spectral channel resolution of intended image in Hz 

211 freqframe frame in which frequency is being expressed in other parameters 

212 msname name of an ms, if empty string it will use the ms's used in selectvis 

213 fieldid fieldid to use when msname is not empty otherwise ignored and field selected in selectvis is used 

214 getfreqrange if set then freqrange is returned in the frame requested for the data selected 

215 spwselection if getfreqrange=True then this is needed to find the range of frequency in the frame requested 

216 

217 Example: 

218 

219 In this example, we are interested in an image cube which span 20.0682GHz to 20.1982 in LSRK which will have a channel resolution of 3.9MHz. The field we are interested is field 4 of each of the ms. 

220 

221 

222 ####### 

223 im.selectvis(vis='test1.ms', field='4', spw='*') 

224 im.selectvis(vis='test2.ms', field='4', spw='*') 

225 selinfo=im.advisechansel(freqstart=2.00682e10, freqend=2.01982e10, freqstep=3.9e3, freqframe='LSRK') 

226 ####The output 'selfinfo' will be a record which will look like thus 

227 {'ms_0': {'nchan': array([109, 23], dtype=int32), 

228 'spw': array([4, 5], dtype=int32), 

229 'start': array([19, 0], dtype=int32)}, 

230 'ms_1': {'nchan': array([109, 23], dtype=int32), 

231 'spw': array([4, 5], dtype=int32), 

232 'start': array([19, 0], dtype=int32)}} 

233 ### 

234 Thus from the first ms a spw selection like '4:19~127, 5:0~22' is all that is needed. 

235 Similarly from the second ms. 

236 

237 ###if you need this info without needing to change the state of the imager tool 

238 then you can it as follows 

239 

240 im.advisechansel(freqstart=2.00682e10, freqend=2.01982e10, freqstep=3.9e3, freqframe='LSRK', msname='test1.ms', fieldid=4) 

241 

242 

243 ####now if you want to see what frequency range is covered, in the frame 

244 ####defined by freqframe, in spwselection you want to use 

245 im.selectvis(vis='test3.ms', spw='0:20~210') 

246 im.advisechansel(getfreqrange=True, freqframe='LSRK') 

247 ### the output will be something 

248 {'freqend': 346020345384.64178, 'freqstart': 345683852920.1723} 

249 

250 ###and if you just want to use it as a helper function without touching the state 

251 ###of imager 

252 

253 im.advisechansel(msname='test3.ms', getfreqrange=True, spwselection='0:20~210') 

254 

255 -------------------------------------------------------------------------------- 

256 

257 """ 

258 return _imager.imager_advisechansel(self, *args, **kwargs) 

259 

260 

261 def approximatepsf(self, *args, **kwargs): 

262 """ 

263 approximatepsf(self, _psf) -> bool 

264 

265 

266 

267 Summary: 

268 Calculate approximate point spread functions 

269 

270 Description: 

271 

272 

273 Calculate the approximate point spread function. 

274 {em Note that the model visibilities are updated}. 

275 

276 Some types of imaging do not yield a well-defined point spread 

277 function. For example, mosaicing or single dish imaging both yield 

278 point spread functions that are position dependent. Nevertheless, one 

279 can still usefully define an {em approximate} PSF that is of some 

280 utility. This is calculated by doing the following calculation: a 

281 point source is located at the center of the specified coordinate 

282 system and the model data predicted. The approximate PSF is then formed from 

283 those model data using the full sky equation. For regular sampling in 

284 the image plane, this approximate PSF is actually quite good. It can 

285 be used in a deconvolution. For a mosaic with similar uv sampling per 

286 pointing, the approximate PSF is roughly the PSF per pointing 

287 multiplied by the primary beam. For a single dish image, it is roughly 

288 the telescope primary beam convolved with itself (if the 

289 gridfunction='pb' was selected). 

290 

291 Input Parameters: 

292 psf Name of output point spread function 

293 

294 Example: 

295 

296 Example of how to make the approximate psf for a mosaic: 

297 

298 im.open('orion.ms') 

299 im.selectvis(spwid=[0, 1] ,field=range(2,11)); 

300 im.defineimage(nx=300, ny=300, cellx='2.0arcsec',celly='2.0arcsec' , stokes='I', phasecenter=6, spwid=[0,1]) 

301 im.weight('natural') 

302 im.setvp(dovp=T, usedefaultvp=True) 

303 im.setoptions(ftmachine='mosaic', padding=1.0) 

304 im.approximatepsf(psf='LePSF.image') 

305 

306 -------------------------------------------------------------------------------- 

307 

308 """ 

309 return _imager.imager_approximatepsf(self, *args, **kwargs) 

310 

311 

312 def boxmask(self, *args, **kwargs): 

313 """ 

314 boxmask(self, _mask, _blc, _trc, _value) -> bool 

315 

316 

317 

318 Summary: 

319 Construct a mask image from blc, trc 

320 

321 Description: 

322 

323 

324 A mask image is an image with the same shape as the other images but 

325 with values between 0.0 and 1.0 as a pixel value. Mask images are used in 

326 imager to control the region selected in a deconvolution. 

327 

328 In the Clark CLEAN, the mask image can usefully have any value between 

329 0.0 and 1.0. Intermediate value discourage but do not rule out 

330 selection of clean components in that region. This is accomplished by 

331 multiplying the residual image by the mask prior to entering the minor 

332 cycle. Note that if you do use a mask for the Clark or Hogbom Clean, 

333 it must cover only a quarter of the image. boxmask does not enforce 

334 this requirement. 

335 

336 Input Parameters: 

337 mask name of mask image 

338 blc Bottom left corner 

339 trc Top right corner, should be image shape 

340 value Value to fill in 

341 

342 Example: 

343 

344 im.boxmask(mask='bigmask', blc=[56,45,1,1], trc=[87,93,4,1]) 

345 im.clean(mask='bigmask', model='3C273XC1.clean.masked', niter=1000) 

346 

347 

348 

349 Makes the image bigmask, and then sets it to unity for all points in 

350 the region bounded by the blc and trc. Then cleans using it as the 

351 mask. 

352 

353 -------------------------------------------------------------------------------- 

354 

355 """ 

356 return _imager.imager_boxmask(self, *args, **kwargs) 

357 

358 

359 def calcuvw(self, *args, **kwargs): 

360 """ 

361 calcuvw(self, _fields, _refcode, _reuse) -> bool 

362 

363 

364 

365 Summary: 

366 Calculates (u, v, w) coordinates for the ms. 

367 

368 Description: 

369 

370 

371 This calculates (u, v, w) positions for the visibilities using the antenna 

372 and feed positions and offsets, the time, and the phase tracking center(s). 

373 

374 

375 Input Parameters: 

376 fields Field IDs (numbered relative to 0) to operate on. Blank = all.  

377 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.  

378 reuse Start from the UVWs in vis (True) or calculate them from the antenna positions? 

379 

380 Example: 

381 

382 im.open('3C273XC1.MS') 

383 im.calcuvw() 

384 im.done() 

385 

386 -------------------------------------------------------------------------------- 

387 

388 """ 

389 return _imager.imager_calcuvw(self, *args, **kwargs) 

390 

391 

392 def clean(self, *args, **kwargs): 

393 """ 

394 clean(self, _algorithm, _niter, _gain, _threshold, _displayprogress, _model, _keepfixed, _complist, _mask, _image, _residual, _psfimage, _interactive, _npercycle, _masktemplate) -> record * 

395 

396 

397 

398 Summary: 

399 Calculate a deconvolved image with selected clean algorithm 

400 

401 Description: 

402 

403 

404 Makes a clean image using either the Hogbom, Clark, multi-scale or multi-field 

405 algorithms. The Clark algorithm is the default. The clean is performed 

406 on the residual image calculated from the visibility data currently 

407 selected. Hence the first step performed in clean is to transform the 

408 current model or models (optionally including a componentlist) to fill 

409 in the MODEL_DATA column, and then inverse transform the residual 

410 visibilities to get a residual image. This residual image is then 

411 cleaned using the corresponding point spread function. This means that 

412 the initial model is used as the starting point for the 

413 deconvolution. Thus if you want to restart a clean, simply set the 

414 model to the model that was previously produced by clean. 

415 

416 Rather than explicit CLEAN boxes, mask images are used to constrain 

417 the region that is to be deconvolved. To make mask images, 

418 use either boxmask (to define a mask 

419 via the corner locations blc and trc) or 

420 mask (to define a mask via 

421 thresholding an existing image) or regionmask (to make masks via regions using the regionmanager or interactively through the viewer) . The default mask is the inner quarter 

422 of the image. 

423 

424 The CLEAN deconvolution is joint in whatever Stokes parameters are 

425 present. Thus it searchs for peaks in either $I$ or $I+|V|$ or 

426 $I+sqrt{Q^2+U^2+V^2}$, the rationale for the latter two forms being 

427 to be biased towards finding strongly polarized pixels first (these 

428 forms are also the maximum eigenvalue of the coherency matrix). The 

429 PSF is constrained to be the same in all polarizations (a feature of 

430 this implementation, not of the Hamaker-Bregman-Sault formalism). But the option of 

431 searching peaks in the stokes planes independently is available via 

432 the {tt clarkstokes} parameter 

433 

434 

435 

436 The clean algorithms possible are: 

437 begin{description} 

438 item[Hogbom] The classic algorithm: points are found iteratively 

439 by searching for the peak. Each point is subtracted from the 

440 full residual image using the shifted and scaled point spread 

441 function. 

442 item[Multiscale] An experimental multi-scale clean algorithm is invoked. 

443 The algorithm is fully described in 

444 deconvolver. 

445 item[Clark] The faster algorithm: the cleaning is split into 

446 minor and major cycles. In the minor cycles only the brightest 

447 points are cleaned, using a subset of the point spread function. 

448 In the major cycle, the points thus found are subtracted correctly 

449 by using an FFT-based convolution. 

450 item[Multi-field] Cleaning is split into minor and major 

451 cycles. For each field, a Clark-style minor cycle is performed. 

452 In the major cycle, the points thus found are subtracted 

453 either from the original visibilities (for multiple fields) 

454 or using a convolution (for only one field). The latter is 

455 much faster. Multi-field imaging has been implemented for 

456 Clark, Hogbom, and Multi-scale deconvolution algorithms. 

457 item[Cotton-Schwab] Cleaning is split into minor and major 

458 cycles. For each field, a Clark-style minor cycle is performed. 

459 In the major cycle, the points thus found are subtracted 

460 from the original visibilities. A fast variant does a convolution 

461 using a FFT. This will be faster for large numbers of 

462 visibilities. Double the image size from that used for Cotton-Schwab 

463 and set a mask to clean only the inner quarter. 

464 item[Wide-field] The user will need to use a wide-field algorithm to 

465 deconvolve if the array is not coplanar over the field of view being 

466 imaged . The technique used is to break the field being imaged into 

467 smaller pieces (facets), over each of which the array appear 

468 planar. We implement a rectangular facetting scheme. If the number of 

469 facets specified in defineimage is 

470 greater than one, Either wfhogbom or wfclark algorithm has to be 

471 selected here to perform a wide-field decovolution. The function 

472 advise can be used to calculate or 

473 check if you need to use a wide-field deconvolution. Note that 

474 aliasing can be reduced by using the {tt padding} argument in 

475 setoptions. In practice the 

476 previous sentence means that if you notice the clean to diverge at the 

477 edges of the facets then you need to use a larger amount of padding 

478 for the FT; the default being 1.2. Wide-field imaging has been 

479 implemented for Clark and Hogbom algorithms. 

480 end{description} 

481 

482 The multi-field clean should be used if either of two conditions 

483 hold: 

484 begin{enumerate} 

485 item Multiple fields are to be cleaned simultaneously {bf OR} 

486 item Primary beam correction is enabled. In this case, a 

487 mosaiced clean is performed. 

488 end{enumerate} 

489 

490 Note that for the single pointing algorithms, only a quarter of the 

491 image may be cleaned. If no mask is set, then the cleaned region 

492 defaults to the inner quarter. If a mask larger than a quarter of the 

493 image is set, then only the inner quarter part of that mask is used. 

494 However, for the wide-field and multi-field imaging (including the 

495 Cotton-Schwab algorithm), the entire field may be imaged because the 

496 major cycles either do an exact subtraction from the visibilities or 

497 because PSF extent is more than twice the extent of the primary beam 

498 support. 

499 

500 Before {tt clean} can be run, you must run {tt selectvis} and {tt defineimage}. 

501 Before {tt clean} can be run with a multi-field algorithm (especially for mosaic), you should run 

502 {tt setvp}. You may want to run {tt setmfcontrol} before running {tt clean} 

503 with a multi-field or wide-field algorithm, though the default control values 

504 may be acceptable. Before {tt clean} can be run with a multi-scale algorithm, 

505 {tt setscales} must be run. 

506 

507 

508 Interactive cleaning/masking: If the user wants to see what the clean 

509 image looks like after npercycle iteration and mask or modify the mask 

510 each time, he/she should set {tt interactive=True} and give npercycle to a 

511 fraction of niter. A viewer with the last residual image along with an 

512 overlayed mask appear after every npercycle iteration. The user can 

513 add or delete regions (by clicking on the appropriate button) to the 

514 mask using the region button and drawing regions and double clicking 

515 inside the region. When satisfied and ready to continue cleaning press 'DONE 

516 with masking' (if the user want to terminate the cleaning process use 

517 the 'STOP' button). The button 'No more mask changes' should be used 

518 if the user want clean to proceed without any further interruption. 

519 Even if {tt interactive=False}, and if the parameter 

520 'mask' is non-empty, it is still used in limiting the search area for 

521 clean components. If the parameter 'masktemplate' is not empty this 

522 means that the user want to use an apriori image to make the mask the 

523 first time (e.g a previously cleaned image) 

524 

525 This function returns a record containing convergence, iterations used and threshold reached. 

526 

527 Input Parameters: 

528 algorithm Algorithm to use 

529 niter Number of Iterations, set to zero for no CLEANing 

530 gain Loop Gain for CLEANing 

531 threshold Flux level at which to stop CLEANing 

532 displayprogress Display the progress of the cleaning? 

533 model Names of clean model images 

534 keepfixed Keep one or more models fixed 

535 complist Name of component list 

536 mask Names of mask images used for CLEANing 

537 image Names of restored images 

538 residual Names of residual images 

539 psfimage Names of psfs if they are needed 

540 interactive whether to stop clean and interactively mask 

541 npercycle If interactive is 'T', then no of iter of clean before stopping, usually a fraction of niter 

542 masktemplate If non empty then will use this image to make the mask the first time 

543 

544 Example: 

545 

546 im.clean(model='3C273XC1.clean.model', 

547 mask='3C283XC1.mask', niter=1000, gain=0.25, threshold='0.03Jy') 

548 

549 

550 A few points should be noted in this example: 

551 

552 begin{itemize} 

553 item When the mask parameter is specified, the number of mask images 

554 listed should be equal to the number of model images. They 

555 should also have the same coordinate system as their 

556 corresponding model images. 

557 item If one or more model images are listed in the model parameter 

558 but the image and residual parameters are empty, the restored 

559 and residual images are automatically named as the model names 

560 appended with '.restored' and '.residual', respectively. 

561 item No restored or residual image is made if the respective image 

562 string is explicitly unset. 

563 end{itemize} 

564 

565 

566 include 'imager.g'; 

567 msfile = 'vlac125K.ms'; 

568 im.open(msfile); 

569 npix = 500; cell='5arcsec'; 

570 # 

571 # CS on 500 by 500 

572 # 

573 im.defineimage(nx=npix, ny=npix, cellx=cell, celly=cell, stokes='I', 

574 spw=[0,1]); 

575 im.setoptions(padding=1.0); 

576 im.selectvis(spwid=[0,1]); 

577 im.clean('cs', model='vlac125K.cs', image='vlac125K.cs.restored', 

578 niter=1000, gain=0.1); 

579 # 

580 # CSF on 1000 by 1000, cleaning a given box 

581 # 

582 

583 im.defineimage(nx=2*npix, ny=2*npix, cellx=cell, celly=cell, stokes='I', 

584 spwid=[1,2]); 

585 reg=rg.box(blc=[400,500], trc=[450,550]) 

586 im.regionmask('vlac125K.mask', region=reg); 

587 im.clean('csf', model='vlac125K.csf', image='vlac125K.csf.restored', 

588 mask='vlac125K.mask', niter=1000, gain=0.1); 

589 

590 # 

591 # CS on 1000 by 1000, cleaning entire image 

592 # 

593 

594 im.defineimage(nx=2*npix, ny=2*npix, cellx=cell, celly=cell, stokes='I', 

595 spwid=[1,2]); 

596 im.clean('cs', model='vlac125K.csl', image='vlac125K.csl.restored', 

597 mask='vlac125K.mask', niter=1000, gain=0.1); 

598 

599 im.done(); 

600 

601 -------------------------------------------------------------------------------- 

602 

603 """ 

604 return _imager.imager_clean(self, *args, **kwargs) 

605 

606 

607 def clipimage(self, *args, **kwargs): 

608 """ 

609 clipimage(self, _image, _threshold) -> bool 

610 

611 

612 

613 Summary: 

614 Zero all pixels where Stokes I is below a threshold 

615 

616 Description: 

617 

618 

619 All pixels in the image with Stokes I less than some threshold 

620 are set to zero. This is useful prior to self-calibration where one 

621 oftens wishes to remove negative pixels from the model. Note that 

622 if the image has polarization information, then the polarized 

623 part of a pixel is also set to zero if Stokes I is less than the 

624 threshold. 

625 

626 Input Parameters: 

627 image name of image 

628 threshold Threshold 

629 

630 Example: 

631 

632 im.clipimage(image='clean', threshold='50mJy') 

633 

634 -------------------------------------------------------------------------------- 

635 

636 """ 

637 return _imager.imager_clipimage(self, *args, **kwargs) 

638 

639 

640 def clipvis(self, *args, **kwargs): 

641 """ 

642 clipvis(self, _threshold) -> bool 

643 

644 

645 

646 Summary: 

647 Flag visibilities where residual exceeds a threshold 

648 

649 Description: 

650 

651 

652 All visibilities where the residual exceeds some threshold 

653 are flagged. This provides a simple way of flagging bad 

654 data. 

655 

656 Input Parameters: 

657 threshold Threshold 

658 

659 Example: 

660 

661 im.plotvis('residual') 

662 # determine threshold then apply it 

663 im.clipvis(threshold='50mJy') 

664 

665 -------------------------------------------------------------------------------- 

666 

667 """ 

668 return _imager.imager_clipvis(self, *args, **kwargs) 

669 

670 

671 def close(self): 

672 """ 

673 close(self) -> bool 

674 

675 

676 

677 Summary: 

678 Close the imager tool, with data written on disk, keeping imager process running for future use 

679 

680 Description: 

681 

682 

683 This is used to close {tt imager} tools. Note that the 

684 data is written to disk. The {tt imager} process keeps running 

685 until a done tool function call is performed. 

686 

687 Example: 

688 

689 im.open('3C273XC1.MS') 

690 im.makeimage(image='3C273XC1.dirty',type='corrected') 

691 im.close() 

692 

693 -------------------------------------------------------------------------------- 

694 

695 """ 

696 return _imager.imager_close(self) 

697 

698 

699 def defineimage(self, *args, **kwargs): 

700 """ 

701 defineimage(self, _nx, _ny, _cellx, _celly, _stokes, _phasecenter, _mode, _nchan, _start, _step, _spw, _restfreq, _outframe, _veltype, _facets, _movingsource, _distance, _projection) -> bool 

702 

703 

704 

705 Summary: 

706 Set the image parameters for subsequent processing 

707 

708 Description: 

709 

710 

711 Define the default image parameters. If an image is to be 

712 made, then these parameters are used in the construction 

713 of the image. Thus, for example, the tool function make 

714 makes an (empty) image using these parameters. 

715 

716 Note that some parameters can be specified either in canonical units 

717 or via measures. To establish default values, the ids for the default 

718 spectral window and default field id must be given. 

719 

720 The parameter {tt mode} can be one of the following: 

721 begin{itemize} 

722 item mfs 

723 item channel 

724 item velocity or opticalvelocity 

725 item frequency 

726 end{itemize} 

727 

728 {tt imager} can perform multi-frequency synthesis over several 

729 spectral windows (mode='mfs'). To achieve this, you should set spwid 

730 to an array of the required spectral windows ({em e.g.} {tt 

731 spwid=[0,1]}). WARNING: For multifrequency synthesis, 'mfs', it is 

732 important that the spwid's selected in selectvis be the SAME 

733 as the one selected in {tt defineimage}. Otherwise the frequency at which 

734 the image is made is not going to be the same as to the one as the one 

735 used in gridding the visibility and can lead to image artifacts. For 

736 {tt mode='velocity'} and {tt mode='frequency'} the {tt step} 

737 parameter has to be a measure/quantity of velocity or frequency, 

738 otherwise for {tt mode='channel'} step is the number of data 

739 channels to be averaged to make one image channel( see examples 

740 below). 

741 

742 

743 The phase center of the image defaults to that of the specified 

744 phasecenter (the first fieldid in the ms is taken if none is 

745 specified), this parameter can be a fieldid or a measure string or the 

746 record output from the direction function of the measures tool( direction ). 

747 This is important if you have multiple pointings in the data. The user 

748 would have used selectvis to select which pointings would be used in imaging. If the 

749 conversion from the observed direction requires frame information then 

750 this is taken as follows: begin{itemize} item Direction information, 

751 including the coordinate system, is taken from the relevant entry in 

752 the Field table of the MeasurementSet. item The epoch is taken from 

753 the time of observation of each visibility. item A position is 

754 specified via the {tt imager} tool function setoptions 

755 end{itemize} 

756 

757 If the specified number of facets is greater than unity then the image 

758 is split into facets (this number along the x and y axes) and 

759 processed. This is necessary when using wide-field algorithm for 

760 deconvolving the image, in cases of non-coplanar arrays (e.g the VLA 

761 at low frequencies but can be safely left at 1 for the ATCA or WSRT). 

762 This is now recommended only when memory or image size is of a problem, 

763 otherwise for widefield issues, wprojection (ftmachine parameter in setoptions) is recommended with a single 

764 facet. 

765 

766 For spectral imaging {tt defineimage} and {tt selectvis} defines the 

767 spectral channels that are imaged. Examples are given in the selectvis section. 

768 The parameter {tt restfreq} can be used to define what rest frequency 

769 to use in the resulting images. If none is specified imager will try 

770 to use the one that is defined in the ms. It will use the first one 

771 defined in the first spectral window selected. 

772 

773 For wide-field or 3D imaging see setoptions 

774 section for some examples. 

775 

776 If the telescope is observing moving source (e.g planet or moon) over 

777 a period of time. One may wish to image in a frame where the source is 

778 fixed. The parameter {tt movingsource} is for that. Setting it to a 

779 source that {tt measures} is aware of will force the imaging to 

780 realign (shift in SD imaging or phase rotation in interferometry 

781 imaging) the data so that the source appears fixed in the 

782 image. Obviously in doing so the background sources will be 

783 blurred. The coordinate system used to fix the source on is the one where 

784 the source is at the first time observed in the selected data. 

785 

786 Input Parameters: 

787 nx Total number of spatial pixels in x 

788 ny Total number of spatial pixels in y 

789 cellx Cellsize in x (e.g. '1arcsec') 

790 celly Cellsize in y (e.g. '1arcsec') 

791 stokes Stokes parameters to image (e.g. 'IQUV') 

792 phasecenter Direction of phase center as a diretion measure or a field id  

793 mode Type of processing (velocity =radiovelocity) 

794 nchan Number of channels; a -1 (default) means all the channels as selected in selectvis and combined into one continuum channel  

795 start Start channel; A 0-relative channel number of the spwid or a frequency quantity or a velocity quantity or radial velocity measure 

796 step Step in channel; integer for number of channels or frequency quantity or velocity quantity or radial velocity measure 

797 spw Spectral Window Id (0 relative) that defines center of image 

798 restfreq rest frequency to use; default =& use the one available in ms  

799 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  

800 veltype velocity definition ('radio' or 'optical' or 'relativistic') 

801 facets Number of facets on each axis 

802 movingsource Name of moving source, e.g planet or moon, to keep fixed in image 

803 distance Distance to object: usually ignore this! (m) 

804 projection map projection type 

805 

806 Example: 

807 

808 ## Example 1 

809 im.defineimage(nx=1024,ny=1024, cellx='30marcsec',celly='30marcsec', 

810 nchan=1, stokes='IV', phasecenter=me.direction('mars')); 

811 ## Example 2 

812 im.defineimage(nx=1024,ny=1024, cellx='30marcsec',celly='30marcsec', 

813 nchan=1, stokes='IV', phasecenter=['J2000', '19:00:30.5', '-45d00m25.6']); 

814 ## Example 3 

815 im.selectvis(nchan=10, start=3, spw=[0,1], field=[3, 4, 5, 6, 7, 9, 10]) 

816 im.defineimage(nx=500, ny=500, mode='mfs', spwid=[0,1], fieldid=7) 

817 im.clean(algorithm='mfclark', niter=1000, model='mosaic.model', image='mosaic.image') 

818 

819 ## Example 4 

820 

821 dir1=me.direction('J2000', '20h00m00', '21d00m00') 

822 dir2=me.direction('J2000', '20h10m00', '21d00m00') 

823 dir3=me.direction('J2000', '20h00m00', '21d03m00') 

824 im.defineimage(nx=100, cellx='0.1arcsec', phasecenter=dir1) 

825 im.make('box1') 

826 im.defineimage(nx=100, cellx='0.1arcsec', phasecenter=dir2) 

827 im.make('box2') 

828 im.defineimage(nx=100, cellx='0.1arcsec', celly='0.1arsec', phasecenter=dir3) 

829 im.make('box3') 

830 im.clean(algorithm='mfclark', model=['box1', 'box2', 'box3'], 

831 image=['box1.restored', 'box2.restored', 'box3.restored'], 

832 residual=['box1.residual', 'box2.residual', 'box3.residual']) 

833 

834 

835 

836 In the first example, the image parameters are set for 1024 by 1024 

837 pixels of 30milli arcsec, 1 channel will be made, Stokes I and V will be 

838 imaged, and the phasecenter will be the direction of Mars as given by 

839 the JPL DE-200 emphemeris. In the second, the phase center is taken 

840 to be an absolute coordinate value. 

841 

842 The third example shows the use of selectvis and defineimage to setup a mosaic. In 

843 the set data we have chosen 10 channels (for each spectral window) of data starting form 

844 channel 3. We also have selected spectral windows 0 and 1. We have selected data from 

845 fields 3 to 10. In the defineimage we decide to use the data to make a 

846 multifrequency synthesis image. We center the image on the field 7 pointing. 

847 

848 The fourth example is use to clean regions where the user knows the 

849 sources are and ignore all the other regions. This is very efficient 

850 in large fields with few sources. Smaller outlier images are made and 

851 deconvolved around known sources rather than making a big image 

852 englobing all three fields. 

853 

854 

855 Now here are some examples about defining cubes using different {tt mode} 

856 parameters. 

857 

858 

859 defining channels cubes use the channel as defined in the data 

860 

861 im.defineimage(cellx=1000, mode='channel', nchan=100, start=10, 

862 step=1, spwid=range(0,10)) 

863 

864 

865 now using frequency and overiding the rest frequency defined in 

866 the ms or if its not defined in the ms 

867 

868 im.defineimage(cellx=1000, mode='frequency', nchan=100, start='1GHz', 

869 step='10kHz', restfrequency='1.421GHz') 

870 

871 

872 in case you have a frame with the frequency 

873 

874 im.defineimage(cellx=1000, mode='frequency', nchan=100, start=['LSRK', 

875 '1GHz'], step='10kHz', restfrequency='1.421GHz') 

876 

877 

878 OR using measures 

879 

880 freqstart=me.frequency('LSRK', '1GHz') 

881 im.defineimage(cellx=1000, mode='frequency', nchan=100, 

882 start=freqstart, step='10kHz', restfrequency='1.421GHz') 

883 

884 

885 similarly if you want to use velocity to define your cube 

886 

887 im.defineimage(cellx=1000, mode='velocity', nchan=100, start=['LSRK', 

888 '10km/s'], step='1m/s', restfrequency='1.421GHz') 

889 OR using measures 

890 velstart=me.radialvelocity('LSRK', '10km/s') 

891 im.defineimage(cellx=1000, mode='velocity', nchan=100, start=velstart, 

892 step='1m/s') 

893 

894 

895 Change mode to 'opticalvelocity' if your velocity values are using optical definition 

896 

897 -------------------------------------------------------------------------------- 

898 

899 """ 

900 return _imager.imager_defineimage(self, *args, **kwargs) 

901 

902 

903 def done(self): 

904 """ 

905 done(self) -> bool 

906 

907 

908 

909 Summary: 

910 Terminate the imager process 

911 

912 Description: 

913 

914 

915 This is used to totally stop the {tt imager} process. It is a good idea 

916 to conserve memory use on your machine by stopping the process once 

917 you no longer need it. 

918 

919 Example: 

920 

921 im.open('3C273XC1.MS') 

922 im.makeimage(image='3C273XC1.dirty',type='corrected') 

923 im.done() 

924 

925 -------------------------------------------------------------------------------- 

926 

927 """ 

928 return _imager.imager_done(self) 

929 

930 

931 def drawmask(self, *args, **kwargs): 

932 """ 

933 drawmask(self, _image, _mask, _niter, _npercycle, _threshold) -> record * 

934 

935 

936 

937 Summary: 

938 Allows you do draw mask using the viewer 

939 

940 Description: 

941 

942 

943 A mask image is an image with the same shape as the other images but 

944 with values between 0.0 and 1.0 as a pixel value. Mask images are used in 

945 imager to control the region selected in a deconvolution. 

946 

947 drawmask is used to interactively draw regions over a template image which you want to allow deconvolution to occur. 

948 

949 Input Parameters: 

950 image name of template image 

951 mask name of image to save mask in  

952 niter Total number of iteration to display in box; just for display or python packaging  

953 npercycle npercycle value to display in box; just for display or python packaging  

954 threshold threshold to display in box ; just for display or python packaging  

955 

956 Example: 

957 

958 im.drawmask(image='mytemplate.image', mask='myregions.mask') 

959 im.clean(mask='myregions.mask', model='3C273XC1.clean.masked', niter=1000) 

960 

961 

962 

963 Make mask image by drawing interactively over a given image 'mytemplate.image', then image and clean the visibilties using it as the 

964 'clean regions'. 

965 

966 -------------------------------------------------------------------------------- 

967 

968 """ 

969 return _imager.imager_drawmask(self, *args, **kwargs) 

970 

971 

972 def exprmask(self, *args, **kwargs): 

973 """ 

974 exprmask(self, _mask, _expr) -> bool 

975 

976 

977 

978 Summary: 

979 Construct a mask image from a LEL expression 

980 

981 Description: 

982 

983 

984 A mask image is an image with the same shape as the other images but 

985 with values between 0.0 and 1.0 as a pixel value. Mask images are used in 

986 imager to control the region selected in a deconvolution. 

987 

988 In the Clark CLEAN, the mask image can usefully have any value between 

989 0.0 and 1.0. Intermediate value discourage but do not rule out 

990 selection of clean components in that region. This is accomplished by 

991 multiplying the residual image by the mask prior to entering the minor 

992 cycle. Note that if you do use a mask for the Clark or Hogbom Clean, 

993 it must cover only a quarter of the image. boxmask does not enforce 

994 this requirement. 

995 

996 This function allows Lattice Express Language (LEL) expressions to 

997 be used in defining a mask. See the documentation on 

998 imagecalc for more details. 

999 

1000 Input Parameters: 

1001 mask name of mask image 

1002 expr Value to set the mask to. Any scalar or LEL expression 

1003 

1004 Example: 

1005 

1006 im.exprmask(mask='bigmask', expr='3C273XC1.clean>0.5') 

1007 im.clean(mask='bigmask', model='3C273XC1.clean.masked', niter=1000) 

1008 

1009 

1010 Makes the image bigmask, and then sets it to unity for all points in 

1011 the region where 3C273XC1.clean is greater than 0.5Jy. 

1012 Then cleans using it as the mask. 

1013 

1014 -------------------------------------------------------------------------------- 

1015 

1016 """ 

1017 return _imager.imager_exprmask(self, *args, **kwargs) 

1018 

1019 

1020 def feather(self, *args, **kwargs): 

1021 """ 

1022 feather(self, _image, _highres, _lowres, _lowpsf, _effdishdiam, _lowpassfiltersd) -> bool 

1023 

1024 

1025 

1026 Summary: 

1027 Feather together an interferometer and a single dish image in the Fourier plane 

1028 

1029 Description: 

1030 

1031 

1032 Basically the 'imerg' algorithm of AIPS and SDE, or the 'feather' 

1033 algorithm of MIRIAD, we regrid the total power (or low resolution) 

1034 image onto the interferometer (or high resolution) image, Fourier 

1035 transform both the interferometer and single dish images, down weight 

1036 the Fourier transform of the interferometer image by 1.0 - FT(low res psf), 

1037 add the weighted interferometer Fourier plane to the single dish Fourier 

1038 plane, and transform back into the image plane. 

1039 

1040 The tapering is by the transform of a point spread function. If lowpsf 

1041 is specified, that image is used, otherwise the appropriate telescope 

1042 beam is used. The point spread function for a single dish image may be 

1043 calculated using makeimage. 

1044 

1045 {tt Advice:} Note that if you are feathering large images, you'd be advised to have 

1046 the number of pixels along the X and Y axes to be composite numbers 

1047 and definitely not prime numbers. In general FFTs work much faster on even 

1048 and composite numbers. You may use subimage function of image 

1049 tool to trim the number of pixels to something desirable. 

1050 

1051 Input Parameters: 

1052 image Name of output feathered image 

1053 highres Name of high resolution (interferometer) image 

1054 lowres Name of low resolution (single dish) image 

1055 lowpsf Name of optional low resolution point spread function 

1056 effdishdiam Optional new SD dish diameter in m to use in feathering; can be smaller than true dish size 

1057 lowpassfiltersd Reject the high spatial frequency of the SD image 

1058 

1059 Example: 

1060 

1061 im.setvp(dovp=True, usedefaultvp=True) 

1062 im.feather(image='feathered.image', highres='casa.vlaonly', 

1063 lowres='casa.sd'); 

1064 

1065 In the above example its using the default beams and the observatory 

1066 information is in the image header. 

1067 

1068 But if you have a single dish image with a beam which is not defined 

1069 in the casa database then the example below is a guide of how to do 

1070 that, say you know the beam of the single dish as a gaussian. 

1071 

1072 

1073 

1074 #create a beam pattern table using vpmanager 

1075 include 'vpmanager.g' 

1076 vpman=vpmanager(); 

1077 vpman.setpbgauss(telescope='OTHER', othertelescope='BONN', 

1078 halfwidth='1arcmin', maxrad='20arcmin', reffreq='1.4GHz'); 

1079 vpman.saveastable('bonn.pb') 

1080 vpman.done() 

1081 

1082 ##....would have done your usual imager setup (defineimage etc) then before feathering 

1083 im.setvp(dovp=True, usedefaultvp=false, vptable='bonn.pb') 

1084 im.feather(image='feathered.image', highres='casa.vlaonly', 

1085 lowres='casa.sd'); 

1086 

1087 ### 

1088 

1089 -------------------------------------------------------------------------------- 

1090 

1091 """ 

1092 return _imager.imager_feather(self, *args, **kwargs) 

1093 

1094 

1095 def filter(self, *args, **kwargs): 

1096 """ 

1097 filter(self, _type, _bmaj, _bmin, _bpa) -> bool 

1098 

1099 

1100 

1101 Summary: 

1102 Apply additional weighting by filtering (u-v taper) 

1103 

1104 Description: 

1105 

1106 

1107 Apply visibility tapering to emphasize certain scale structures. The 

1108 imaging tapers are applied to a Table column called IMAGING_WEIGHT, 

1109 which may be plotted using 

1110 tb and pl. 

1111 plotweights. 

1112 In addition, this column 

1113 may be accessed directly using either the table 

1114 or ms modules. Note that the taper is multiplicative and 

1115 so the weights must be calculated first using 

1116 weight. The points are not flagged! 

1117 

1118 Note that the scale size to be emphasized is given in the image plane 

1119 as the parameters of the corresponding Gaussian. Note also use of this 

1120 function provides an optimum detection for the given scale size, which 

1121 is not the same as requiring that the resulting dirty beam have the 

1122 specified Gaussian fit. The resultant fitted beam size will {em very 

1123 roughly} be the quadratic sum of the original beam and the specified 

1124 beam. If you wish to obtain a specified beam, then the best approach 

1125 is to perform this calculation and check the value obtained using 

1126 imager.fitpsf. 

1127 

1128 Input Parameters: 

1129 type Type of filtering or u-v tapering 

1130 bmaj Major axis of filter 

1131 bmin Minor axis of filter 

1132 bpa Position angle of filter 

1133 

1134 Example: 

1135 

1136 im.weight('uniform') 

1137 im.filter(type='gaussian', bmaj='2.3arcsec', bmin='1.67arcsec', 

1138 bpa='-34.5deg') 

1139 

1140 -------------------------------------------------------------------------------- 

1141 

1142 """ 

1143 return _imager.imager_filter(self, *args, **kwargs) 

1144 

1145 

1146 def fitpsf(self, *args, **kwargs): 

1147 """ 

1148 fitpsf(self, _psf, _bmaj, _bmin, _bpa) -> bool 

1149 

1150 

1151 

1152 Summary: 

1153 Fit the point spread function, making psf image first if needed 

1154 

1155 Description: 

1156 

1157 

1158 This fits an elliptical Gaussian to the point spread function 

1159 and returns the fitted beam parameters. If psf image is not specified 

1160 then a psf is made and used. The values for the beam fit 

1161 are saved internally and used whenever needed (for example in the functions restore or smooth) until invalidated. The values 

1162 are invalidated by selectvis, defineimage or any tool function that changes 

1163 the weights. Use the function summary to check if there is a valid fitted psf stored internally. 

1164 

1165 

1166 Input Parameters: 

1167 psf Name of input psf 

1168 

1169 Output Parameters: 

1170 bmaj Major axis of beam 

1171 bmin Minor axis of beam 

1172 bpa Position angle of beam 

1173 

1174 Example: 

1175 

1176 im.makeimage(type='psf', image='3C273XC1.psf') 

1177 params=im.fitpsf('3C273XC1.psf') 

1178 #This returns a python dict params here 

1179 print params['bmaj'].value, params['bmin'].value, params['bpa'] 

1180 im.restore(model='bla' , complist='', image='bla.restored' , residual='bla2.residual' ) 

1181 

1182 

1183 Or if one wants to generate a psf from the uv coverage and use that subsequently as in the following example: 

1184 

1185 

1186 - im.fitpsf(psf='') 

1187 - im.restore(model='bla' , complist='', image='bla.restored' , residual='bla2.residual' ) 

1188 

1189 -------------------------------------------------------------------------------- 

1190 

1191 """ 

1192 return _imager.imager_fitpsf(self, *args, **kwargs) 

1193 

1194 

1195 def fixvis(self, *args, **kwargs): 

1196 """ 

1197 fixvis(self, _fields, _phasedirs, _refcode, _distances, _datacolumn) -> bool 

1198 

1199 

1200 

1201 Summary: 

1202 Performs visibility adjustments. 

1203 

1204 Description: 

1205 

1206 

1207 Corrects UVW coordinates and optionally the visibilities for various 

1208 effects that can be calculated without fitting a model to the data. 

1209 

1210 The effects include: 

1211 begin{itemize} 

1212 item changing the phase tracking center(s), 

1213 item correcting for differential aberration, (Not yet implemented) 

1214 item changing the equinox (i.e. B1950_VLA to J2000 or APP, etc.) of the UVW coordinates, 

1215 item changing the projection, as in (-)NCP to SIN. (Not yet implemented), 

1216 item refocusing. 

1217 end{itemize} 

1218 

1219 

1220 Input Parameters: 

1221 fields Field IDs (numbered relative to 0) to operate on. Blank = all.  

1222 phasedirs Phase tracking centers for each field in fields, in the same order.  

1223 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.  

1224 distances A list of distances (in m) for the fields listed in fields. 0 = infinity.  

1225 datacolumn Which of DATA, MODEL_DATA, and/or CORRECTED_DATA to operate on. Default: 'all'.  

1226 

1227 Example: 

1228 

1229 im.open('3C273XC1.MS') 

1230 im.fixvis() 

1231 im.done() 

1232 

1233 -------------------------------------------------------------------------------- 

1234 

1235 """ 

1236 return _imager.imager_fixvis(self, *args, **kwargs) 

1237 

1238 

1239 def ft(self, *args, **kwargs): 

1240 """ 

1241 ft(self, _model, _complist, _incremental, _phasecentertime) -> bool 

1242 

1243 

1244 

1245 Summary: 

1246 Fourier transform the specified model and componentlist 

1247 

1248 Description: 

1249 

1250 

1251 Fourier transform the specified model (and optionally componentlist) 

1252 and insert into the MODEL_DATA column. The current contents of 

1253 the MODEL_DATA column are replaced unless incremental is set to 

1254 T (in which case the results are added to the column). 

1255 phasecentertime is optional useful for field which is have time varying phasecenters (polynomials or ephemerides phasecenters). The default is to calculate the phasecenter at each time in the data but the time provided here can be used to calculate phasecenters. 

1256 If the function setvp is run prior to running ft with a componentlist, then the spectral variation of each component in the componentlist will include the multiplicative term of the beam value for each channel frequency. So a flat spectrum component will show the frequency variation of the beam in the predicted visibilities.. 

1257 

1258 Input Parameters: 

1259 model Name of image 

1260 complist Name of component list 

1261 incremental Add to the existing MODEL_DATA column? 

1262 phasecentertime Time to use for time varying phasecenters 

1263 

1264 Example: 

1265 

1266 im.ft(model='3C273XC1.nnls.model') 

1267 im.ft(model='3C273XC1.another.model', incremental=True) 

1268 

1269 

1270 Fourier transforms the model in the image 3C273XC1.nnls.model 

1271 and then adds the visibility due to 3C273XC1.another.model 

1272 

1273 -------------------------------------------------------------------------------- 

1274 

1275 """ 

1276 return _imager.imager_ft(self, *args, **kwargs) 

1277 

1278 

1279 def getweightgrid(self, *args, **kwargs): 

1280 """ 

1281 getweightgrid(self, _type, _wgtimages) -> variant * 

1282 

1283 

1284 

1285 Summary: 

1286 get the requested weight grids 

1287 

1288 Description: 

1289 

1290 

1291 

1292 This is a utility function when running multi imager processes in parallel on subsection of an ms/data independently 

1293 One would wish to weight the dirty image before averaging or set the imaging weight density (when using unform or 

1294 Brigg's style weighting) to account for all the data being used. This is {bf NOT} for the general user but for people who 

1295 are parallelizing at the scripting level. 

1296 

1297 {bf imaging}: will return a the weight griddensity  

1298 

1299 {bf ftweight}: will put the FT-machine weight images in the names given in wgtimage parameters..these may be needed to average residual images from different processes running seperately on different section of the data. 

1300 

1301 Input Parameters: 

1302 type Type of weight requested (imaging, ftweight) 

1303 wgtimages names of weightimages to save 

1304 

1305 Example: 

1306 

1307 wght=im.getweightgrid('imaging') 

1308 wght2=im2.getweightgrid('imaging') 

1309 wght=wght+wght2 

1310 

1311 im.setweightgrid(weight=wght, type='imaging') 

1312 

1313 -------------------------------------------------------------------------------- 

1314 

1315 """ 

1316 return _imager.imager_getweightgrid(self, *args, **kwargs) 

1317 

1318 

1319 def linearmosaic(self, *args, **kwargs): 

1320 """ 

1321 linearmosaic(self, _images, _mosaic, _fluxscale, _sensitivity, _fieldids, _usedefaultvp, _vptable) -> bool 

1322 

1323 

1324 

1325 Summary: 

1326 Make a linear mosaic of several images 

1327 

1328 Description: 

1329 

1330 

1331 Make a linear mosaic of several images. 

1332 Currently, the pointing center is not specified in the image, so 

1333 we specify the pointing center in terms of the row numbers of the FIELD subtable. 

1334 

1335 Input Parameters: 

1336 images Input images to be mosaiced 

1337 mosaic Output mosaic image 

1338 fluxscale Fluxscale image 

1339 sensitivity Sensitivity image 

1340 fieldids List of field ids that correspond each of the images,used to center the PB of each image. (0-based list) 

1341 usedefaultvp Use the default vp type? 

1342 vptable Voltage pattern table from the vpmanager for detailed specification 

1343 

1344 Example: 

1345 

1346 im.linearmosaic(images=['orion.1.cln', 'orion.2.cln', 'orion.4.cln'], mosaic='orion.linmos', 

1347 fluxscale='orion.linmos.fluxscale', fieldid=[1,2,4]); 

1348 

1349 -------------------------------------------------------------------------------- 

1350 

1351 """ 

1352 return _imager.imager_linearmosaic(self, *args, **kwargs) 

1353 

1354 

1355 def make(self, *args, **kwargs): 

1356 """ 

1357 make(self, _image) -> bool 

1358 

1359 

1360 

1361 Summary: 

1362 Make an empty (i.e. blank) image 

1363 

1364 Description: 

1365 

1366 

1367 Make an empty image using the current image parameters. Often this is 

1368 unnecessary, but you will typically need to use this if you wish to 

1369 deconvolve a set of images. The steps are to make the empty images 

1370 that you require to be deconvolved, and then pass them into clean as a 

1371 vector of strings. 

1372 

1373 Input Parameters: 

1374 image name of output image 

1375 

1376 Example: 

1377 

1378 im.defineimage(nx=1024,ny=1024, cellx='30marcsec',celly='30marcsec', 

1379 nchan=1, stokes='IV', phasecenter=me.direction('mars')); 

1380 im.make('mars.moving'); 

1381 im.defineimage(nx=1024,ny=1024, cellx='30marcsec',celly='30marcsec', 

1382 nchan=1, stokes='IV', 

1383 phasecenter=me.direction('J2000', '12:23:48.7', '-15:56:32.9') 

1384 im.make('mars.fixed'); 

1385 im.clean(algorithm='mf', model=['mars.moving', 'mars.fixed'], 

1386 image=['mars.moving.restored', 'mars.fixed.restored']) 

1387 

1388 

1389 This makes two empty images, one moving with mars and one fixed 

1390 in J2000, and then deconvolves the two jointly using clean. 

1391 Finally the images are restored. 

1392 

1393 -------------------------------------------------------------------------------- 

1394 

1395 """ 

1396 return _imager.imager_make(self, *args, **kwargs) 

1397 

1398 

1399 def predictcomp(self, *args, **kwargs): 

1400 """ 

1401 predictcomp(self, _objname, _standard, _epoch, _freqs, _pfx) -> string 

1402 

1403 

1404 

1405 Summary: 

1406 Make a component list for a known object 

1407 

1408 Description: 

1409 

1410 

1411 Make a component list for an object recognized by standard, one of setjy's 

1412 flux density standards. 

1413 

1414 Input Parameters: 

1415 objname Name of the object 

1416 standard Name of the flux standard 

1417 epoch Time to use, as an epoch measure, e.g. me.epoch('UTC', '55555d'), for Solar System objects 

1418 freqs The frequencies to use, in Hz 

1419 pfx Prefix for the name of the component list 

1420 

1421 Example: 

1422 

1423 clname = im.predictcomp('Ceres', 'Butler-JPL-Horizons 2010', 

1424 '2012-02-14/13:33:00', [3.45e11, 6.90e11], 'vd_') 

1425 

1426 This writes a component 'list' named vd_spw0_Ceres_345GHz55971.6d.cl to disk 

1427 containing a uniform disk component for Ceres as it is expected to appear at 

1428 345 and 690 GHz at 2012-02-14/13:33:00 UTC, and returns the name of the 

1429 component list. Returns '' on error. 

1430 

1431 -------------------------------------------------------------------------------- 

1432 

1433 """ 

1434 return _imager.imager_predictcomp(self, *args, **kwargs) 

1435 

1436 

1437 def makeimage(self, *args, **kwargs): 

1438 """ 

1439 makeimage(self, _type, _image, _compleximage, _verbose) -> bool 

1440 

1441 

1442 

1443 Summary: 

1444 Calculate images by gridding, etc. 

1445 

1446 Description: 

1447 

1448 

1449 This tool function actually does gridding (and Fourier inversion if 

1450 needed) of visibility data to make an image. It allows calculation of 

1451 various types of image: 

1452 begin{description} 

1453 item[observed] Make the dirty image from the DATA column ({em default}) 

1454 item[model] Make the dirty image from the MODEL_DATA column 

1455 item[corrected] Make the dirty image from the CORRECTED_DATA column 

1456 item[residual] Make the dirty image from the difference of the 

1457 CORRECTED_DATA and MODEL_DATA columns 

1458 item[psf] Make the point spread function 

1459 item[singledish] Make a single dish image 

1460 item[coverage] Make a single dish coverage image 

1461 item[holography] Make a complex holography image 

1462 item[pb] Make the primary beam as defined by setvp 

1463 end{description} 

1464 

1465 Note the full {tt imager} equation is not used and so, for example, the 

1466 primary beam correction is not performed. Use 

1467 restore to get a residual image 

1468 using the full {tt imager} equation where primary beam correction is 

1469 performed. 

1470 

1471 A position shift can be applied when specifying the image parameters 

1472 with defineimage. If a shift is specified then 

1473 the uvw coordinates are reprojected prior to gridding, and a phase 

1474 rotation is applied. If the image is a PSF then no phase shift is 

1475 applied but the uvw are recomputed. To see the effects of the uvw 

1476 reprojected, you can use the 

1477 plotuv function. 

1478 

1479 If desired, the full complex image (before conversion to stokes 

1480 I,Q,U,V) may be retained. Note that the image 

1481 tool cannot load a complex image directly. Instead, use the 

1482 imagecalc constructor 

1483 to take {em e.g.} the real and imaginary parts of the image. 

1484 

1485 For making single dish and holography images, the data are convolved onto the 

1486 grid using a one of a number of options: 

1487 begin{description} 

1488 item[gridfunction='SF'] Circularly symmetric prolate spheroidal wavefunction. 

1489 This is always the same function in pixels. To get this to match to 

1490 the antenna primary beam, the optimum cellsize to use in constructing 

1491 the image is the antenna primary beam half-width-half-maximum times 

1492 1.20192. 

1493 item[gridfunction='BOX'] Nearest neighbor gridding. 

1494 item[gridfunction='PB'] The telescope primary beam is used as the 

1495 convolution function. This function is the same in arcseconds, 

1496 independent of the cellsize. This choice is optimum in the least 

1497 squares sense. To override the default choice of telescope primary beam 

1498 for a given telescope, use the function 

1499 setvp. Usually the default will be acceptable. 

1500 end{description} 

1501 

1502 To make a reasonable approximation to the sky, one should divide 

1503 the type='singledish' image by the type='coverage' image, thresholding 

1504 at some level. For example: 

1505 

1506 begin{verbatim} 

1507 

1508 ia.open('scanweight'); 

1509 ia.statistics(s); 

1510 threshold = s.max / 10.0; 

1511 # 

1512 ia.imagecalc('sdimage', 

1513 pixels=spaste('scanimage[scanweight>', threshold, 

1514 ']/scanweight[scanweight>', threshold, ']')) 

1515 ###ia.view(raster=True, axislabels=True); 

1516 end{verbatim} 

1517 

1518 Input Parameters: 

1519 type Type of output image 

1520 image Name of output image 

1521 compleximage Name of output complex image 

1522 verbose Report things like the center frequency to the logger 

1523 

1524 Example: 

1525 

1526 im.ft(model='3C273XC1.model', complist='3C273XC1.complist'); 

1527 im.makeimage(type='residual', image='3C273XC1.residual') 

1528 im.makeimage(type='psf', image='3C273XC1.psf') 

1529 

1530 

1531 Fill in the MODEL_DATA column from Fourier transforming the model and 

1532 the componentlist. Make the residual image and write it to 

1533 3C273XC1.residual. 

1534 

1535 

1536 im.setvp(dovp=T, usedefaultvp=T, telescope='GBT'); 

1537 im.makeimage(type='pb', image='gbt.pb') 

1538 

1539 

1540 

1541 In the above we may want to see what the primary beam we are using 

1542 look like. May also be useful to deconvolve single dish images in the 

1543 deconvolver tool. 

1544 

1545 -------------------------------------------------------------------------------- 

1546 

1547 """ 

1548 return _imager.imager_makeimage(self, *args, **kwargs) 

1549 

1550 

1551 def makemodelfromsd(self, *args, **kwargs): 

1552 """ 

1553 makemodelfromsd(self, _sdimage, _modelimage, _sdpsf, _maskimage) -> bool 

1554 

1555 

1556 

1557 Summary: 

1558 Make an initial model image from a Single Dish image 

1559 

1560 Description: 

1561 

1562 

1563 This functions use an image from a single dish and make a model 

1564 (clean component) image out of it. This allows one to use this as the 

1565 starting model in a deconvoltion function e.g 

1566 clean or mem 

1567 This provides an alternative to 

1568 feather. 

1569 The difference between the two is that in {tt feather} the 

1570 interferometer image is deconvolved first and the single dish image is 

1571 put in at the end. Whereas if one starts with a model from the single 

1572 dish image it will give a different starting point for the deconvolving 

1573 algorithm to interpolate the missing short baseline. 

1574 

1575 The function setsdoptions may be used to set 

1576 a factor by which to scale the SD image, if necessary. 

1577 

1578 The {tt sdpsf} parameter (optional) should be used if an external PSF image of the 

1579 single dish is needed to calculate the beam parameters of the primary 

1580 beam of the dish. This is usually needed if the dish image is from a 

1581 non standard telescope or the beam is not in the {tt CASA} system. 

1582 

1583 The {tt mask} is a mask image that may be needed to be used for 

1584 clean. This is usually the case when the dish image does not fully 

1585 cover the field defined by defineimage. 

1586 

1587 Input Parameters: 

1588 sdimage Single Dish image 

1589 modelimage Name of output image to be used as model 

1590 sdpsf PSF of Single Dish if needed 

1591 maskimage mask image 

1592 

1593 Example: 

1594 

1595 im.open('orion_only.ms') 

1596 im.selectvis(field=range(10), spw=range(2)) 

1597 im.defineimage(nx=1000, cellx='1arcsec', , phasecenter=4, spwid=[0,1]) 

1598 im.setvp(dovp=T) 

1599 im.setoptions(ftmachine='mosaic') 

1600 im.setscales(nscales=3) 

1601 im.setsdoptions(scale=0.9); 

1602 im.makemodelfromsd(sdimage='orion_gbt.im', modelimage='orion_model', maskimage='orion.mask') 

1603 im.clean(algorithm='mfmultiscale', model='orion_model', 

1604 residual='orion.residual', image='orion.restored', gain=0.2, niter=500, mask='orion.mask') 

1605 

1606 

1607 In the above example we are making a mosaic with the fields 0 to 9. A 

1608 single dish image {tt orion_gbt.im} is used scaled down by a factor 0.9 to 

1609 make the initial model that is passed to multi-scale clean. 

1610 

1611 -------------------------------------------------------------------------------- 

1612 

1613 """ 

1614 return _imager.imager_makemodelfromsd(self, *args, **kwargs) 

1615 

1616 

1617 def mask(self, *args, **kwargs): 

1618 """ 

1619 mask(self, _image, _mask, _threshold) -> bool 

1620 

1621 

1622 

1623 Summary: 

1624 Construct a mask image by thresholding an image 

1625 

1626 Description: 

1627 

1628 

1629 A mask image is an image with the same shape as the other images but 

1630 with values between 0.0 and 1.0 as a pixel value. Mask images are used 

1631 in {tt imager} to control the region selected in a deconvolution. 

1632 One makes a mask image by clipping the I part of the restored image 

1633 (this function) or via the boxmask, 

1634 regionmask, and 

1635 exprmask functions. In this 

1636 function, all points greater than the threshold are set to unity. The 

1637 mask is the same in I,Q,U, and V. Note that 

1638 exprmask is the most powerful 

1639 method for making mask images. 

1640 

1641 In the Clark CLEAN, the mask image can usefully have any value between 

1642 0.0 and 1.0. Intermediate value discourage but do not rule out 

1643 selection of clean components in that region. This is accomplished by 

1644 multiplying the residual image by the mask prior to entering the minor 

1645 cycle. 

1646 

1647 Note that if you do use a mask for the Clark or Hogbom Clean, it must 

1648 cover only a quarter of the image. It is particularly important to 

1649 check this when creating an image using a threshold. If it extends 

1650 further, the easiest fix is to use 

1651 getchunk and 

1652 getchunk to set parts of it to zero. 

1653 

1654 Input Parameters: 

1655 image name of template image 

1656 mask name of mask image 

1657 threshold threshold for mask 

1658 

1659 Example: 

1660 

1661 im.mask( image='bigimage', mask='bigmask',threshold='0.07Jy') 

1662 im.clean(mask='bigmask', model='3C273XC1.clean.masked', niter=1000) 

1663 

1664 

1665 Makes the image bigmask, and then sets it to unity 

1666 for all points where the Stokes I in bigimage is 

1667 greater than 0.07. Then clean using it as the mask. 

1668 

1669 -------------------------------------------------------------------------------- 

1670 

1671 """ 

1672 return _imager.imager_mask(self, *args, **kwargs) 

1673 

1674 

1675 def mem(self, *args, **kwargs): 

1676 """ 

1677 mem(self, _algorithm, _niter, _sigma, _targetflux, _constrainflux, _displayprogress, _model, _keepfixed, _complist, _prior, _mask, _image, _residual) -> bool 

1678 

1679 

1680 

1681 Summary: 

1682 Calculate a deconvolved image with selected mem (maximum entropy) algorithm 

1683 

1684 Description: 

1685 

1686 

1687 Makes a mem image using either the Cornwell-Evans maximum entropy or 

1688 maximum emptiness algorithms, using the single field or multi-field 

1689 contexts. The maximum entropy algorithm is the default. The mem is performed 

1690 on the residual image calculated from the visibility data currently 

1691 selected. Hence the first step performed in mem is to transform the 

1692 current model or models (optionally including a componentlist) to fill 

1693 in the MODEL_DATA column, and then inverse transform the residual 

1694 visibilities to get a residual image. This residual image is then 

1695 deconvolved using the corresponding point spread function. This means that 

1696 the initial model is used as the starting point for the 

1697 deconvolution. Thus if you want to restart a mem, simply set the 

1698 model to the model that was previously produced by clean. 

1699 

1700 Mask images are used to constrain the region that is to be 

1701 deconvolved. To make mask images, use either 

1702 boxmask (to define a mask via the 

1703 corner locations blc and trc) or mask (to 

1704 define a mask via thresholding an existing image). The default mask is 

1705 the inner quarter of the image. 

1706 

1707 The MEM deconvolution only operates on one Stokes parameter at a time. 

1708 Joint MEM deconvolution for multiple Stokes parameters will be 

1709 implemented in the future. 

1710 

1711 Some reference regarding MEM : 

1712 Cornwell and Evans, 

1713 Astronomy and Astrophysics (ISSN 0004-6361), vol. 143, no. 1, Feb. 1985, 

1714 p. 77-83. 

1715 

1716 Narayan and Nityananda, 

1717 Annual review of astronomy and astrophysics. Volume 24 (A87-26730 

1718 10-90). Palo Alto, CA, Annual Reviews, Inc., 1986, p. 127-170. 

1719 

1720 The mem algorithms possible are: 

1721 begin{description} 

1722 item[Cornwell-Evans Maximum Entropy (entropy)] The classic 'vm' or 'vtess' 

1723 deconvolution algorithm. 

1724 item[Cornwell-Evans Maximum Emptiness (emptiness)] The historic, but 

1725 largely undocumented, modification to the Cornwell-Evans algorithm 

1726 which seeks a model image which is consistent with the data and 

1727 simultaneously minimizes the number of pixels with no emission 

1728 (meaning 'with pixel values below the noise level'). 

1729 item[Multi-field Maximum Entropy (mfentropy)] Deconvolution is split 

1730 into minor and major cycles. For each field, the MEM analog of a Clark 

1731 Clean minor cycle is performed. In the major cycle, the emission thus 

1732 modelled is subtracted either from the original visibilities (for 

1733 multiple fields) or using a convolution (for only one field). The 

1734 latter is much faster. 

1735 item[Multi-field Maximum Emptiness (mfemptiness)] Just like {tt mfentropy}, 

1736 but with emptiness. 

1737 end{description} 

1738 

1739 The multi-field mem ({tt mfentropy} or {tt mfemptiness}) should be 

1740 used if either of two conditions hold: 

1741 begin{enumerate} 

1742 item Multiple fields are to be deconvolved simultaneously {bf OR} 

1743 item Primary beam correction is enabled. In this case, a 

1744 mosaiced mem is performed. 

1745 end{enumerate} 

1746 

1747 Note that for the single pointing algorithms, only a quarter of the 

1748 image may be deconvolved. If no mask is set, then the deconvolved 

1749 region defaults to the inner quarter. If a mask larger than a quarter 

1750 of the image is set, then only the quarter starting at the bottom left 

1751 corner is used. However, for the multi-field imaging, the entire 

1752 field may be imaged because the major cycles either do an exact 

1753 subtraction from the visibilities or because PSF extent is more than 

1754 twice the extent of the primary beam support. 

1755 

1756 Before {tt mem} can be run, you must run {tt selectvis} and {tt defineimage}. 

1757 Before {tt mem} can be run with a multi-field algorithm, you should run 

1758 {tt setvp}. You may want to run {tt setmfcontrol} before running {tt mem} 

1759 with a multi-field algorithm, though the default control values 

1760 may be acceptable. 

1761 

1762 Input Parameters: 

1763 algorithm Algorithm to use 

1764 niter Number of Iterations 

1765 sigma Image sigma to try to achieve 

1766 targetflux Target flux for final image 

1767 constrainflux Constrain image to match target flux? else targetflux used only to initialize model 

1768 displayprogress Display the progress of the cleaning? 

1769 model Names of model images 

1770 keepfixed Keep model fixed 

1771 complist Name of component list 

1772 prior Names of mem prior images 

1773 mask Names of mask images (0=>no emission, 1=>emission permitted 

1774 image Names of restored images 

1775 residual Names of residual images 

1776 

1777 Example: 

1778 

1779 im.mem(model='3C273XC1.mem.model', 

1780 mask='3C283XC1.mask', niter=40, sigma='0.001Jy') 

1781 

1782 -------------------------------------------------------------------------------- 

1783 

1784 """ 

1785 return _imager.imager_mem(self, *args, **kwargs) 

1786 

1787 

1788 def nnls(self, *args, **kwargs): 

1789 """ 

1790 nnls(self, _model, _keepfixed, _complist, _niter, _tolerance, _fluxmask, _datamask, _image, _residual) -> bool 

1791 

1792 

1793 

1794 Summary: 

1795 Calculate a deconvolved image using the NNLS algorithm 

1796 

1797 Description: 

1798 

1799 

1800 

1801 Solve for the model brightness using the Briggs' Non-Negative Least 

1802 Squares algorithm. Since NNLS works only on the $I$ image, the $I$ 

1803 pixels in the current image is set to zero where the fluxmask is $> 0.0$, 

1804 then NNLS is used to estimate the $I$-pixels for that region. 

1805 The deconvolution is performed on the residual image calculated from 

1806 the visibility data currently selected. Hence the first step performed 

1807 in clean is to transform the current model to fill in the MODEL_DATA 

1808 column, and then inverse transform the residual visibilities to get a 

1809 residual image. This residual image is then deconvolved using the 

1810 corresponding point spread function. 

1811 

1812 Some other points to remember are that rather than explicit boxes, 

1813 mask images are used to constrain the region that is to be 

1814 deconvolved. For NNLS, there are two masks, the fluxmask specifying 

1815 the region within which flux is allowed, and the datamask specifying 

1816 the region of the dirty image to be used as constraints. Typically the 

1817 datamask will be somewhat larger than the fluxmask. On a large 

1818 machine, a practical limit to both will be about 5000-6000 

1819 pixels. Hence NNLS is only useful for compact tools. (For more 

1820 details, see the htmladdnormallink{Briggs thesis}{briggsURL}). To 

1821 make mask images, use either boxmask (to 

1822 define a mask via the corner locations blc and trc) or 

1823 mask (to define a mask via 

1824 thresholding an existing image). 

1825 

1826 On the canonical aipspp machine with 64MBytes of physical memory, 

1827 you should try to keep the product of the pixels in the fluxmask 

1828 and the datamask below about 5-10 million. Otherwise the 

1829 solution phase will swap badly. 

1830 

1831 Input Parameters: 

1832 model Name of image 

1833 keepfixed Keep model fixed 

1834 complist Name of component list 

1835 niter Number of Iterations, set to zero for no NNLS 

1836 tolerance Tolerance for solution 

1837 fluxmask Name of mask for allowed flux 

1838 datamask Name of mask for constraint pixels in dirty image 

1839 image Names of restored images 

1840 residual Names of restored images 

1841 

1842 Example: 

1843 

1844 im.nnls(image='3C273XC1.nnls.image', model='3C273XC1.nnls.model', 

1845 fluxmask='3C283XC1.fluxmask', datamask='3C273XC1.datamask', niter=1000, 

1846 tolerance=0.00001) 

1847 

1848 -------------------------------------------------------------------------------- 

1849 

1850 """ 

1851 return _imager.imager_nnls(self, *args, **kwargs) 

1852 

1853 

1854 def open(self, *args, **kwargs): 

1855 """ 

1856 open(self, _thems, _compress, _usescratch) -> bool 

1857 

1858 

1859 

1860 Summary: 

1861 Open a new MeasurementSet, for processing, closing current MeasurementSet 

1862 

1863 Description: 

1864 

1865 

1866 Close the current MeasurementSet and open a new MeasurementSet 

1867 instead. The current state of {tt imager} is retained, except for 

1868 the data selection. 

1869 

1870 Input Parameters: 

1871 thems New MeasurementSet to be processed 

1872 compress Compress calibration columns? 

1873 usescratch If true: Imager will use corrected data column and make scratch columns of they donot exist 

1874 

1875 -------------------------------------------------------------------------------- 

1876 

1877 """ 

1878 return _imager.imager_open(self, *args, **kwargs) 

1879 

1880 

1881 def pb(self, *args, **kwargs): 

1882 """ 

1883 pb(self, _inimage, _outimage, _incomps, _outcomps, _operation, _pointingcenter, _parangle, _pborvp) -> bool 

1884 

1885 

1886 

1887 Summary: 

1888 Applies or corrects for a primary beam 

1889 

1890 Description: 

1891 

1892 

1893 

1894 Multiply ({tt operation='apply'}) or divide ({tt operation='correct'}) 

1895 by the primary beam function. The primary beam can be applied to images and/or 

1896 Componentlists. 

1897 

1898 If {tt pointingcenter==false} then you must specify {tt inimage} 

1899 and the pointing center is taken from its reference direction. 

1900 Otherwise, {tt pointingcenter} must be a Direction measure. 

1901 It cannot take on the value {tt True}. 

1902 

1903 The applied primary beam function is deterimed as follows. If you used 

1904 function Imager.setvp to set an external 

1905 voltage pattern table, then this is where the applied primary beam will 

1906 come from (regardless of whether you set {tt inimage} or not). If you 

1907 did not run this function, then you must supply argument {tt inimage}. 

1908 The telescope name embedded in its Coordinate System will be used to 

1909 determine the primary beam function. 

1910 

1911 Input Parameters: 

1912 inimage Input image to apply beam to 

1913 outimage Output image after beam is applied 

1914 incomps Input Componentlist table name 

1915 outcomps Output Componentlist table name 

1916 operation Operation 

1917 pointingcenter Pointing center for primary beam application: default N.Pole 

1918 parangle Parallactic angle for calculation 

1919 pborvp Primary Beam or Voltage Pattern 

1920 

1921 Example: 

1922 

1923 # make a flat image 

1924 im.make('flat.image'); 

1925 ia.open('flat.image'); 

1926 arr=ia.getchunk(); 

1927 arr[0:len(arr), 0:len(arr[0])] = 1.0; 

1928 ia.putchunk(arr); 

1929 ia.done() 

1930 arr = false; 

1931 # 

1932 # as we are using 'pointingcenter=F', it defaults to the image center 

1933 im.pb(inimage='flat.image', outimage='pb.image', pointingcenter=F) 

1934 

1935 -------------------------------------------------------------------------------- 

1936 

1937 """ 

1938 return _imager.imager_pb(self, *args, **kwargs) 

1939 

1940 

1941 def plotsummary(self): 

1942 """ 

1943 plotsummary(self) -> bool 

1944 

1945 

1946 

1947 Summary: 

1948 Plot a summary of field and spectral window ids 

1949 

1950 Description: 

1951 

1952 

1953 Performs a simple plot of the field and spectral window IDs 

1954 versus time (after sorting). 

1955 

1956 Example: 

1957 

1958 m = fitstoms('3C273XC1.ms', '3C273XC1.fits'); m.close() 

1959 im.open('3C273XC1.ms') 

1960 im.plotsummary() 

1961 

1962 -------------------------------------------------------------------------------- 

1963 

1964 """ 

1965 return _imager.imager_plotsummary(self) 

1966 

1967 

1968 def plotuv(self, *args, **kwargs): 

1969 """ 

1970 plotuv(self, _rotate) -> bool 

1971 

1972 

1973 

1974 Summary: 

1975 Plot the uv coverage 

1976 

1977 Description: 

1978 

1979 

1980 Performs a simple plot of the uv coverage of all selected data. 

1981 

1982 Optionally, plotuv will rotate the uvw coordinates to the 

1983 specified phase center (set via defineimage). 

1984 

1985 Input Parameters: 

1986 rotate Rotate uvw coordinates to specified phase center? 

1987 

1988 Example: 

1989 

1990 im.open('3C273XC1.ms') 

1991 im.plotuv(false) 

1992 

1993 -------------------------------------------------------------------------------- 

1994 

1995 """ 

1996 return _imager.imager_plotuv(self, *args, **kwargs) 

1997 

1998 

1999 def plotvis(self, *args, **kwargs): 

2000 """ 

2001 plotvis(self, _type, _increment) -> bool 

2002 

2003 

2004 

2005 Summary: 

2006 Plot the visibility amplitudes as a function of u-v radius (also, see visplot tool 

2007 

2008 Description: 

2009 

2010 

2011 Performs a simple plot of the visibility amplitudes of all selected data. 

2012 

2013 Input Parameters: 

2014 type Type of plot: can contain all, observed, corrected, model, residual 

2015 increment Increment in points to plot 

2016 

2017 Example: 

2018 

2019 im.open('3C273XC1.ms') 

2020 im.plotvis(increment=10) 

2021 

2022 -------------------------------------------------------------------------------- 

2023 

2024 """ 

2025 return _imager.imager_plotvis(self, *args, **kwargs) 

2026 

2027 

2028 def plotweights(self, *args, **kwargs): 

2029 """ 

2030 plotweights(self, _gridded, _increment) -> bool 

2031 

2032 

2033 

2034 Summary: 

2035 Plot the visibility weights as a function of u-v radius 

2036 

2037 Description: 

2038 

2039 

2040 Performs a plot of the visibility weights of all selected data (stored in 

2041 the IMAGING_WEIGHT column of the MeasurementSet). 

2042 The plot can be of the gridded weights (type='gridded') or 

2043 ungridded. 

2044 

2045 

2046 

2047 Input Parameters: 

2048 gridded Do gridded plot? 

2049 increment Increment in points to plot 

2050 

2051 Example: 

2052 

2053 im.open('3C273XC1.ms') 

2054 im.defineimage(cellx='0.7arcsec', celly='0.7arcsec') 

2055 im.weight('briggs') 

2056 im.plotweights(gridded=True,increment=10) 

2057 

2058 -------------------------------------------------------------------------------- 

2059 

2060 """ 

2061 return _imager.imager_plotweights(self, *args, **kwargs) 

2062 

2063 

2064 def regionmask(self, *args, **kwargs): 

2065 """ 

2066 regionmask(self, _mask, _region, _boxes, _circles, _value) -> bool 

2067 

2068 

2069 

2070 Summary: 

2071 Construct a mask image from a region 

2072 

2073 Description: 

2074 

2075 

2076 A mask image is an image with the same shape as the other images but 

2077 with values between 0.0 and 1.0 as a pixel value. Mask images are used in 

2078 imager to control the region selected in a deconvolution. 

2079 

2080 In the Clark CLEAN, the mask image can usefully have any value between 

2081 0.0 and 1.0. Intermediate value is discouraged but do not rule out 

2082 selection of clean components in that region. This is accomplished by 

2083 multiplying the residual image by the mask prior to entering the minor 

2084 cycle. Note that if you do use a mask for the Clark or Hogbom Clean, 

2085 it must cover only a quarter of the image. {tt regionmask} does not enforce 

2086 this requirement. 

2087 

2088 The function regionmask also allows multiple regions to be used. A record of the regions can be made as in the example below. 

2089 

2090 Regions can be made in many different ways using the 

2091 regionmanager functions. An example 

2092 using wbox function is given 

2093 below. The default regionmanager tool 'rg' can be used for cases the user want to have flexibility in manipulating regions. The {tt region} parameter takes a record that comes from the regionmanager output. 

2094 The parameter boxes allow the user to sent in a list of 4 elements numbers representing blc's and trc's 

2095 

2096 If both the parameters, {tt regions} and {tt boxes} are used the a union is done with the two sets of region thus defined. 

2097 

2098 

2099 

2100 

2101 

2102 Input Parameters: 

2103 mask name of mask image 

2104 region Region record usually from regionmanager 

2105 boxes list of 4 elements lists e.g [[xblc1, yblc1, xtrc1, ytrc1], [[xblc2, yblc2, xtrc2, ytrc2]] 

2106 circles list of 3 elements lists e.g [[rad0, xcen0, ycen0], [rad1,xcen1, ycen1], .....] 

2107 value Value to set the mask to 

2108 

2109 Example: 

2110 

2111 Makes a mask then cleans using it. 

2112 

2113 im.open('test.ms') 

2114 im.selectvis(field=0, spw=0) 

2115 im.defineimage(nx=400, cellx='0.001arcsec', phasecenter=0) 

2116 a=[100.0, 100.0, 200, 200.0] 

2117 b=[50, 50, 80, 80] 

2118 im.regionmask(mask='bigmask', boxes=[a,b]) 

2119 im.clean(mask='bigmask', model='3C273XC1.clean.masked', niter=1000) 

2120 

2121 Another example using rg.wbox function: 

2122 ia.open('dirty') 

2123 cs = ia.coordsys() 

2124 rg.setcoordinates(cs.record()) 

2125 r1 = dg.wbox(blc=['173pix', '347pix'], trc=['183pix', '370pix']) 

2126 im.regionmask(mask='bigmask',region=r1) 

2127 

2128 Or using a dict of regions: 

2129 

2130 r2=rg.wbox(blc=['180pix', '344pix'], trc=['191pix', '369pix']) 

2131 r3=rg.wbox(blc=['189pix', '341pix'], trc=['204pix', '364pix']) 

2132 regs={'reg1'':r1, 'reg2':r2, 'reg3':r3} 

2133 rec=rg.makeunion(regs) 

2134 im.regionmask(mask='bigmask',region=rec) 

2135 

2136 If quantities are to be used to define regions the following is a an example 

2137 

2138 im.regionmask(mask='joetest',boxes=['15:23:32.902','+05.19.32.089','15:22:28.631','+05.28.52.474']) 

2139 

2140 -------------------------------------------------------------------------------- 

2141 

2142 """ 

2143 return _imager.imager_regionmask(self, *args, **kwargs) 

2144 

2145 

2146 def regiontoimagemask(self, *args, **kwargs): 

2147 """ 

2148 regiontoimagemask(self, _mask, _region, _boxes, _circles, _value) -> bool 

2149 

2150 

2151 

2152 Summary: 

2153 union a mask image with various regions 

2154 

2155 Description: 

2156 

2157 

2158 

2159 

2160 This function is very similar to regionmask function 

2161 except that the mask image has to be existant already and this is an 

2162 independent helper function (i.e does not care about the state of the imager tool... e.g does not need imager to have an 

2163 attached ms). 

2164 

2165 

2166 

2167 

2168 

2169 Input Parameters: 

2170 mask name of mask image 

2171 region Region record usually from regionmanager 

2172 boxes list of 4 elements lists e.g [[xblc1, yblc1, xtrc1, ytrc1], [[xblc2, yblc2, xtrc2, ytrc2]] 

2173 circles list of 3 elements lists e.g [[rad0, xcen0, ycen0], [rad1,xcen1, ycen1], .....] 

2174 value Value to set the mask to 

2175 

2176 Example: 

2177 

2178 Makes a mask then cleans using it. 

2179 

2180 a=[100.0, 100.0, 200, 200.0] 

2181 b=[50, 50, 80, 80] 

2182 im.regiontoimagemask(mask='bigmask', boxes=[a,b]) 

2183 im.clean(mask='bigmask', model='3C273XC1.clean.masked', niter=1000) 

2184 

2185 Another example using rg.wbox function: 

2186 ia.open('dirty') 

2187 cs = ia.coordsys() 

2188 rg.setcoordinates(cs.record()) 

2189 r1 = dg.wbox(blc=['173pix', '347pix'], trc=['183pix', '370pix']) 

2190 im.regionmask(mask='bigmask',region=r1) 

2191 

2192 Or using a dict of regions: 

2193 

2194 r2=rg.wbox(blc=['180pix', '344pix'], trc=['191pix', '369pix']) 

2195 r3=rg.wbox(blc=['189pix', '341pix'], trc=['204pix', '364pix']) 

2196 regs={'reg1'':r1, 'reg2':r2, 'reg3':r3} 

2197 rec=rg.makeunion(regs) 

2198 im.regionmask(mask='bigmask',region=rec) 

2199 

2200 If quantities are to be used to define regions the following is a an example 

2201 

2202 im.regionmask(mask='joetest',boxes=['15:23:32.902','+05.19.32.089','15:22:28.631','+05.28.52.474']) 

2203 

2204 -------------------------------------------------------------------------------- 

2205 

2206 """ 

2207 return _imager.imager_regiontoimagemask(self, *args, **kwargs) 

2208 

2209 

2210 def residual(self, *args, **kwargs): 

2211 """ 

2212 residual(self, _model, _complist, _image) -> bool 

2213 

2214 

2215 

2216 Summary: 

2217 Calculate the residual image with respect to current model and component list 

2218 

2219 Description: 

2220 

2221 

2222 Calculate the residuals corresponding to the model and 

2223 componentlist. {em Note that the model visibilities are updated}. 

2224 

2225 Input Parameters: 

2226 model Names of input models 

2227 complist Name of component list 

2228 image Names of output residual images 

2229 

2230 Example: 

2231 

2232 - im.residual(model='3C273XC1.clean', complist='3C273XC1.cl', 

2233 image='3C273XC1.clean.residual') 

2234 

2235 -------------------------------------------------------------------------------- 

2236 

2237 """ 

2238 return _imager.imager_residual(self, *args, **kwargs) 

2239 

2240 

2241 def restore(self, *args, **kwargs): 

2242 """ 

2243 restore(self, _model, _complist, _image, _residual) -> bool 

2244 

2245 

2246 

2247 Summary: 

2248 Calculate the restored image with restored model, component list, and residuals 

2249 

2250 Description: 

2251 

2252 

2253 Restore the residuals to a smoothed version of the model. The model 

2254 images are convolved with the specified Gaussian beam and then the 

2255 residual images are added. {em Note that the model visibilities are 

2256 updated and thus reflect the model and componentlist that was 

2257 used.}. Use setbeam to set the beam 

2258 parameters. 

2259 

2260 Input Parameters: 

2261 model Names of input model 

2262 complist Name of component list 

2263 image Names of output restored images 

2264 residual Names of residual images 

2265 

2266 Example: 

2267 

2268 - im.setbeam(bmaj='2.0arcsec', bmin='2.0arcsec') 

2269 - im.restore(model='3C273XC1.clean', image='3C273XC1.clean.restored', 

2270 

2271 -------------------------------------------------------------------------------- 

2272 

2273 """ 

2274 return _imager.imager_restore(self, *args, **kwargs) 

2275 

2276 

2277 def updateresidual(self, *args, **kwargs): 

2278 """ 

2279 updateresidual(self, _model, _complist, _image, _residual) -> bool 

2280 

2281 

2282 

2283 Summary: 

2284 Calculate the residual and restored images with new modified model, component list, 

2285 

2286 Description: 

2287 

2288 

2289 This function is for efficiency and speed purpose only. Same as restore 

2290 It is to be used after you have used clean or mem ...but you wish to tweak the model image, say by clipping unwanted components and it will avoid unnecessary recalculating of psf but will do a proper prediction of the new model visibilities and recalculate residual and restored images. 

2291 

2292 Input Parameters: 

2293 model Names of input model 

2294 complist Name of component list 

2295 image Names of output restored images 

2296 residual Names of residual images 

2297 

2298 Example: 

2299 

2300 - im.setbeam(bmaj='2.0arcsec', bmin='2.0arcsec') 

2301 - im.restore(model='3C273XC1.clean', image='3C273XC1.clean.restored', 

2302 

2303 -------------------------------------------------------------------------------- 

2304 

2305 """ 

2306 return _imager.imager_updateresidual(self, *args, **kwargs) 

2307 

2308 

2309 def sensitivity(self, *args, **kwargs): 

2310 """ 

2311 sensitivity(self, _pointsource, _relative, _sumweights, _senrec) -> bool 

2312 

2313 

2314 

2315 Summary: 

2316 Calculate rms sensitivity 

2317 

2318 Description: 

2319 

2320 

2321 

2322 NB: The implementation in this function will be removed for CASA v4.5. 

2323 We now recommend that the im.apparentsens() function be used instead 

2324 of this one, especially if their weights are initialized and 

2325 calibrated. 

2326 

2327 Calculate the point source sensitivity for the selected data, both 

2328 absolutely and relatively (to that for natural weighting). 

2329 

2330 To do the calculation, we use the imaging weights (in the 

2331 column called IMAGING_WEIGHT) as calculated from the WEIGHT column, 

2332 and an estimate of the effective net bandwidth and integration time. 

2333 The calculation therefore includes all the effects 

2334 of weight and 

2335 filter. 

2336 

2337 The output is an array with mixed elements. Counting from zero, the 

2338 second element (out[1]) is the net sensitivity, third element is the 

2339 ratio of the reduction in sensitivity due to the chosen weighting 

2340 scheme. This ratio is 1.0 for Natural weight and greater than one for 

2341 all other weighting schemes. (NOTE: Further testing is required of 

2342 this value and hence this is kept separate for now). 

2343 

2344 The sensitivity calculations require Tsys and collecting area of 

2345 the antenna. These quantities are not known from the MS. The 

2346 sensitivity is therefore returned in units of Jy m^2/K. Multiplying the 

2347 second elements with the ration of the Tsys and effective antenna 

2348 collecting area will give the sensitivity in Jy/beam units. 

2349 

2350 The fourth elements of the return value is a record with the following 

2351 keys: 'nbaselines', 'effectiveintegration', 'effectivebandwidth', 

2352 'sumwt' and 'spwid'. These can be used to get the number of baselines 

2353 used, effective integration time (in sec), the effective bandwidth (in 

2354 Hz), the sum of weights and the absolute spectral window IDs used. 

2355 

2356 Output Parameters: 

2357 pointsource Calculated point source sensitivity (Jy m^2 / (K beam)) 

2358 relative Calculated relative sensitivity 

2359 sumweights Calculated sum of weights 

2360 senrec Record per SPW per chan sensitivity calculations 

2361 

2362 Example: 

2363 

2364 a=im.sensitivity(false); 

2365 print 'Sensitivity =', a[1]; 

2366 print 'Relative to Natural Weighting = ', a[2]; 

2367 

2368 -------------------------------------------------------------------------------- 

2369 

2370 """ 

2371 return _imager.imager_sensitivity(self, *args, **kwargs) 

2372 

2373 

2374 def apparentsens(self, *args, **kwargs): 

2375 """ 

2376 apparentsens(self, _pointsource, _relative) -> bool 

2377 

2378 

2379 

2380 Summary: 

2381 Calculate rms sensitivity directly from weights 

2382 

2383 Description: 

2384 

2385 

2386 

2387 This function calculates the point source sensitivity for the data 

2388 selected by im.selectvis(...), and according to the imaging weighting 

2389 parameters specified in im.weight(...) and im.defineimage(...). The 

2390 calculation is performed solely using the weight information stored in 

2391 the MS WEIGHT column (WEIGHT_SPECTRUM tbd), and as adjusted by the net 

2392 imaging weighting function (natural, uniform, robust, taper, etc.). 

2393 Therefore, it is assumed that the MS WEIGHTs have been properly 

2394 initialized and calibrated along with the visibility data. As long as 

2395 the WEIGHTs are in the inverse square units of the visibilities (i.e., 

2396 inverse variance weights), the calculation should yield the real 

2397 theoretical imaging sensitivity for data at any stage of the 

2398 calibration (though data at early and intermediate stages of 

2399 calibration may not be sufficiently coherent for imaging at high--or 

2400 even modest--fidelity). 

2401 

2402 Two values are reported in the logger and returned (see example 

2403 below). First, the apparent sensitivity (in the units implied by the 

2404 WEIGHTs' units), for the specified imaging weighting scheme. Second, 

2405 a unitless factor describing the ratio of the apparent sensitivity to 

2406 that obtained with pure 'natural' weighting (the nominal peak 

2407 sensitivity). When 'natural' weighting is selected, this ratio factor 

2408 will be 1.0; all other weighting choices will yield an apparent 

2409 sensitivity ratio greater than 1.0. 

2410 

2411 Currently, this function reports only the continuum sensitivity for 

2412 the selected data, and in particular, for the aggregate bandwidth 

2413 indicated by the spectral window selection. The calculation further 

2414 assumes that the visibility samples are each entirely independent 

2415 (i.e., no redundant samples such as would occur for overlapping 

2416 spectral windows). 

2417 

2418 A future version of this function will support reporting a sensitivity 

2419 spectrum for the spectral line case (including support for 

2420 WEIGHT_SPECTRUM). For now, spectral line sensitivity may be 

2421 reasonably estimated by dividing the reported sensitivity by the 

2422 square root of the fractional bandwidth of a single image channel, or 

2423 by selecting a bandwidth matching the width of a single image channel. 

2424 

2425 Output Parameters: 

2426 pointsource Calculated apparent point source sensitivity (in units implied by the MS weights) 

2427 relative Ratio of apparent sensitivity relative to natural weighting 

2428 

2429 Example: 

2430 

2431 # open and set up selection and image plane parameters 

2432 im.open('mydata.ms') 

2433 im.selectvis(field='2',spw='0') 

2434 im.defineimage(mode='mfs',spw=0,stokes='I',cellx='15arcsec',celly='15arcsec',nx=256,ny=256) 

2435 

2436 # report natural weighting sensitivity 

2437 im.weight(type='natural') 

2438 nat=im.apparentsens(); 

2439 print 'Natural Sensitivity =', nat[1]; 

2440 print 'Relative to Natural Weighting = ', nat[2]; 

2441 

2442 # switch to uniform weighting 

2443 im.weight(type='uniform') 

2444 uni=im.apparentsens(); 

2445 print 'Uniform Sensitivity =', uni[1]; 

2446 print 'Relative to Natural Weighting = ', uni[2]; 

2447 

2448 # switch to briggs weighting 

2449 im.weight(type='briggs',robust=0.0) 

2450 rob=im.apparentsens(); 

2451 print 'Briggs Sensitivity =', rob[1]; 

2452 print 'Relative to Natural Weighting = ', rob[2]; 

2453 

2454 im.close() 

2455 

2456 -------------------------------------------------------------------------------- 

2457 

2458 """ 

2459 return _imager.imager_apparentsens(self, *args, **kwargs) 

2460 

2461 

2462 def setbeam(self, *args, **kwargs): 

2463 """ 

2464 setbeam(self, _bmaj, _bmin, _bpa) -> bool 

2465 

2466 

2467 

2468 Summary: 

2469 Set the beam parameters for clean restoration 

2470 

2471 Description: 

2472 

2473 

2474 This sets the clean beam that will be used in all restoration 

2475 operations. 

2476 

2477 Input Parameters: 

2478 bmaj Major axis of beam 

2479 bmin Minor axis of beam 

2480 bpa Position angle of beam 

2481 

2482 -------------------------------------------------------------------------------- 

2483 

2484 """ 

2485 return _imager.imager_setbeam(self, *args, **kwargs) 

2486 

2487 

2488 def selectvis(self, *args, **kwargs): 

2489 """ 

2490 selectvis(self, _vis, _nchan, _start, _step, _spw, _field, _baseline, _time, _scan, _intent, _observation, _uvrange, _taql, _usescratch, _datainmemory, _writeaccess) -> bool 

2491 

2492 

2493 

2494 Summary: 

2495 Select visibilities for subsequent processing 

2496 

2497 Description: 

2498 

2499 

2500 This setup tool function selects which data are to be used 

2501 subsequently. After invocation of selectvis, only the selected 

2502 data are operated on. Thus, for example, in imaging, only the selected 

2503 data are gridded into an image, and in plotting, only the 

2504 selected data are plotted. 

2505 

2506 Data can be selected by field and spectral window ids. Note that 

2507 all data thus selected are passed to imaging, and may or 

2508 may not be imaged, depending on how the image was constructed 

2509 using defineimage. For example, 

2510 in mosaicing, use fieldid in defineimage to control what pointing 

2511 is used to define the field center, and use fieldid in selectvis 

2512 to control what pointings are used in the imaging. 

2513 

2514 For spectral processing, it is possible to make cubes out 

2515 multi-spectral window selections but the selection and combination can 

2516 be a bit confusing (any hint at how to make it clearer is welcome). 

2517 

2518 If the default values are not used, then data to be used can be selected channel wise. The 

2519 

2520 begin{description} 

2521 item[nchan] is the number of data channels selected. It 

2522 defaults to -1 (interpreted as all channels). 

2523 item[start] is the first channel from input dataset that is to be used. 

2524 It defaults to 0 (i.e. first channel). 

2525 item[step] gives the increment between selected input channels. It defaults to 1 channel. A value of {tt n} means that {tt n-1} data channels will not not be used. 

2526 end{description} 

2527 

2528 

2529 

2530 By choosing the parameters for selectvis and defineimage correctly, 

2531 one may obtain various mappings of visibility channels to image 

2532 channels. For example, to average 512 visibility channels into 64 

2533 image channels (producing image channels consisting of 8 

2534 visibility channels): 

2535 

2536 

2537 im.defineimage(mode='channel', spw=0, nchan=64, start=1, step=8); 

2538 im.selectvis(spw=0, nchan=512, start=1, step=1) 

2539 im.clean(.....); 

2540 

2541 

2542 This averages the spectral channels during the gridding process. If 

2543 one wanted to only include every 8th channel in the 

2544 deconvolution, one would do: 

2545 

2546 

2547 im.selectvis(nchan=64, start=1, step=8) 

2548 im.defineimage(mode='channel', nchan=64, start=1, step=8); 

2549 im.clean(....); 

2550 

2551 

2552 For velocity and opticalvelocity modes, the mstart and mstep 

2553 are the start and step velocities as strings. 

2554 

2555 

2556 im.defineimage(mode='velocity', nchan=64, start='20 km/s', step='-100m/s'); 

2557 im.selectvis(spwid=[-1]); ###selecting all data spectral windows 

2558 im.clean(...); 

2559 

2560 

2561 If the image and data selections differ, then averaging is done during 

2562 the gridding and degridding process in the image deconvolution. 

2563 

2564 

2565 im.defineimage(mode='channel', nchan=64, start=1, step=8); 

2566 im.selectvis(nchan=512, start=1, step=1) 

2567 im.clean() 

2568 

2569 

2570 Note: The channels numbers used in {tt defineimage} 

2571 and {tt selectvis} refers to the same channel. So if a channel is not 

2572 selected in {tt selectvis} but is selected in {tt defineimage}, then 

2573 blank channels image are made. The example below will result in the 

2574 having the first 6 (0-5) channels in the image to be blank. 

2575 

2576 

2577 im.selectvis(nchan=50, start=6, step=1) #selected chan 6-55 

2578 im.defineimage(mode='channel', nchan=50, start=0, step=1); 

2579 

2580 # will try to image channel 1-50. But as previously only channel 6-55 

2581 # was selected only channel 6-50 will have data; images of channels 

2582 # 1-5 are blank 

2583 im.clean(....) 

2584 

2585 

2586 For multi-spectral window cube imaging the selection of the data can 

2587 be done as follows 

2588 

2589 

2590 im.selectvis(nchan=[50,60], start=[0,0], step=[1,1], 

2591 spw=[0,1]) 

2592 im.defineimage(mode='channel', nchan=110, start=0, step=1, spw=[0,1]); 

2593 

2594 

2595 

2596 The above means that you would make a data selection of 50 channels 

2597 (starting from 0 steping 1) from the first spectral window and 60 

2598 channels (starting from 1 steping 1). The defineimage defines the image 

2599 to be a cube of 110 channels. The caveat is the step size in the 

2600 frequency direction is the step size of the first spectral window. If 

2601 the step size of channels of the two spectral windows are different 

2602 then one is better off defining the image cube in velocities (e.g. as below). 

2603 

2604 

2605 

2606 im.selectvis(nchan=[50,60], start=[0,0], step=[1,1], 

2607 spw=[1,2]) 

2608 im.defineimage(mode='velocity', nchan=200, mstart='20km/s', 

2609 mstep='-100m/s'); 

2610 

2611 

2612 Input Parameters: 

2613 vis Measurementset for which this selection applies; an empty string '' implies that it is to be applied in ms used in open 

2614 nchan Number of channels to select 

2615 start Start channels (0-relative) 

2616 step Step in channel number 

2617 spw Spectral Window Ids (0 relative) to select; -1 interpreted as all 

2618 field Field Ids (0 relative) or Field names (msselection syntax and wilcards are used) to select 

2619 baseline Antenna Ids (0 relative) or Antenna names (msselection syntax and wilcards are used) to select 

2620 time Limit data selected to be within a given time range. The syntax is defined in the msselection link 

2621 scan Limit data selected on scan numbers. The syntax is defined in the msselection link 

2622 intent Limit data selected on observation intent. The syntax is defined in the msselection link 

2623 observation Limit data using observation IDs. The syntax is defined in the msselection link 

2624 uvrange Limit data selected on uv distance. The syntax is defined in the msselection link 

2625 taql For the TAQL experts, flexible data selection using the TAQL syntax 

2626 usescratch If True: imager will use CORRECTED_DATA column and will make scratch columns and store Model visibilities after deconvolution 

2627 datainmemory If True: imager will load the selected ms memory; useful if imaging a few channels that fit in memory 

2628 writeaccess If False: imager will open the ms in readmode; useful for multiple process access to the MS 

2629 

2630 Example: 

2631 

2632 im.open('3C273XC1.MS'); 

2633 im.selectvis(nchan=512,start=1,step=1, taql='SCAN_NUMBER > 10 && FIELD_ID==2') 

2634 

2635 

2636 Time range selection 

2637 

2638 im.selectvis(field=range(0,10), time='> 2000/09/21/12:00:00') 

2639 

2640 

2641 select some antennas, for all fields that begins with {tt 'ngc'} 

2642 

2643 im.selectvis(field='ngc*', baseline=[0, 10, 20]) 

2644 

2645 

2646 And for those that the standard parameters are not flexible enough 

2647 there is the taql parameter. This for people who knows the different 

2648 columns of the MeasurementSet 

2649 

2650 im.selectvis(taql='ANTENNA1==0 && ANTENNA2==3') 

2651 

2652 

2653 Imager allows the user to make an image from multiple ms, without the 

2654 need to concatenate them. To do this then the im.open method should 

2655 {bf not} be used at all but multiple calls of selectvis with the 

2656 parameter vis pointing to each ms should be used. The other 

2657 parameters can be used to make selection on each ms 

2658 

2659 

2660 im.selectvis(vis='myms1.ms', field=0, spw=[0,1], nchan=[40, 50], start=[5,10]) 

2661 im.selectvis(vis='myms2.ms', field=10, spw=[2], nchan=[40], start=[5]) 

2662 im.selectvis(vis='myms3.ms', field=range(0,10), time='> 2002/10/15/20:30:45') 

2663 

2664 -------------------------------------------------------------------------------- 

2665 

2666 """ 

2667 return _imager.imager_selectvis(self, *args, **kwargs) 

2668 

2669 

2670 def setjy(self, *args, **kwargs): 

2671 """ 

2672 setjy(self, _field, _spw, _modimage, _fluxdensity, _standard, _scalebychan, _spix, _reffreq, _polindex, _polangle, _rotmeas, _time, _scan, _intent, _observation, _interpolation) -> record * 

2673 

2674 

2675 

2676 Summary: 

2677 Compute the model visibility for a specified source flux density 

2678 

2679 Description: 

2680 

2681 

2682 Compute the model visibility for a specified source flux density, and 

2683 insert into the MODEL_DATA column. The source flux density for 

2684 a set of standard flux density reference sources may optionally 

2685 be pre-computed, by setting the input flux density to -1 (the default). 

2686 At present, these include 3C286, 3C48, 3C147, 3C138, and 1934-638. 

2687 In this case, if the source is not in this set, an unpolarized 

2688 flux density of 1 Jy will be assumed. Users may also specify 

2689 {tt standard='SOURCE'} to use the model(s) in the SOURCE_MODEL column of the 

2690 SOURCE subtable. 

2691 

2692 Users may also specify a model image that will be scaled to the 

2693 specified total flux density (or that computed for reference sources). 

2694 When a model image is specified, setjy will only permit processing 

2695 one field, and will currently only process Stokes I. 

2696 

2697 Input Parameters: 

2698 field Field Id (0-relative) or name 

2699 spw Spectral Window Id. (0-relative) 

2700 modimage A model image 

2701 fluxdensity Specified flux density (I,Q,U,V) in Jy (lookup the value; use 1.0 if not found)  

2702 standard Flux density standard 

2703 scalebychan Do the flux scaling on a per channel basis else on a spw basis. Effectively True if fluxdensity is specified. 

2704 spix Spectral index for fluxdensity. S = fluxdensity * (freq/reffreq)**spix 

2705 reffreq Reference frequency for spix. 

2706 polindex Coefficients for Taylor expansion of Polarization index 

2707 polangle Coefficients for Taylor expansion of Polarization angle in radians 

2708 rotmeas rotation measure (rad/lambda**2) 

2709 time Time range to operate on 

2710 scan Scan(s) to operate on 

2711 intent Observation intent 

2712 observation Observation ID(s) to operate on 

2713 interpolation interpolation method in the case of time variable calibrator 

2714 

2715 Example: 

2716 

2717 im.setjy(fieldid=2, spwid=-1, fluxdensity=[2.6,0.2,0.3,0.5],standard='Baars') 

2718 

2719 

2720 Compute the model visibility for field id. 2 to the specified 

2721 point-source (I,Q,U,V) for all spectral windows id.'s on the 

2722 Baars flux density scale. 

2723 

2724 -------------------------------------------------------------------------------- 

2725 

2726 """ 

2727 return _imager.imager_setjy(self, *args, **kwargs) 

2728 

2729 

2730 def ssoflux(self): 

2731 """ 

2732 ssoflux(self) -> bool 

2733 

2734 

2735 

2736 Summary: 

2737 Use setjy instead. 

2738 

2739 Description: 

2740 

2741 

2742 *This was an experimental clone of setjy while flux calibration with Solar 

2743 System objects was being tested. It has been merged back into setjy.* 

2744 

2745 -------------------------------------------------------------------------------- 

2746 

2747 """ 

2748 return _imager.imager_ssoflux(self) 

2749 

2750 

2751 def setmfcontrol(self, *args, **kwargs): 

2752 """ 

2753 setmfcontrol(self, _cyclefactor, _cyclespeedup, _cyclemaxpsffraction, _stoplargenegatives, _stoppointmode, _minpb, _scaletype, _constpb, _fluxscale, _flatnoise) -> bool 

2754 

2755 

2756 

2757 Summary: 

2758 Set various cycle control parameters for multi-field and wide-field imageing. 

2759 

2760 Description: 

2761 

2762 

2763 Control parameters for mosaicing or wide-field imaging which are not 

2764 required in single field deconvolution are set here to streamline the 

2765 user interface. As multifield and widefield imaging is accomplished 

2766 by deconvolution in cycles, many of these parameters control how the 

2767 deconvolution cycles are ended. 

2768 

2769 begin{description} 

2770 item cyclefactor: this parameter helps in lowering or increasing the 

2771 threshold at which the deconvolution cycle will stop and degrid and 

2772 subtract from the visibilities. For very bad PSFs you may want to 

2773 reconcile with the visibilties often, thus a larger number is 

2774 required here...(4 to 5). For very well behaved data you may want to 

2775 deconvolve deep before reconciling: a lower number is used (1.5 to 2.0). 

2776 item cyclespeedup: this is used if the PSF is not well behaved and 

2777 you want clean to raise by 2 the threshold if it has not reached the 

2778 threshold in this number of iteration 

2779 item cyclemaxpsffraction: similar to cyclefactor, but this is an 

2780 explicit fraction of the PSF peak. The final threshold is computed 

2781 using min( cyclemaxpsffraction, cyclefactor * maxPSFsidelobe). 

2782 Valid values are between 0.0 and 1.0. 

2783 item stoplargenegatives: This parameter is exclusively for when using 

2784 multiscale clean. This is used to stop the component 

2785 search when the largest scale has found this number of negative 

2786 components. -1 here means that continue component search even if the 

2787 largest component is negative. 

2788 item stoppointmode: Again exclusively for when using multiscale 

2789 clean. The clean will stop if the smallest scale receives this 

2790 number of consecutive components. 

2791 item minpb: This is to defined up to what level the voltage pattern 

2792 is going to applied when using 

2793 setvp. The default is 0.1 of the 

2794 primary beam or the voltage pattern defined for the antenna. 

2795 item scaletype: This parameter cab be NONE or SAULT. If NONE the 

2796 image is not scaled, if SAULT is used the image is weighted so that 

2797 the noise is kept uniform across the image. The next two parameters 

2798 defines how the SAULT weighting is limited. Obviously then the flux 

2799 scale is not uniform across the image. To get the right flux 

2800 multiply the image with the fluxscale image. 

2801 item constpb: this parameter defines up to what amplitude of the 

2802 Primary beam the noise floor is kept uniform, when using SAULT as scaletype. 

2803 item fluxscale: use this to give a filename to store the factor image 

2804 to apply to the image to get the fluxscale right. 

2805 item flatnoise: (default true) Set to false if you want clean components for mosaic to be searched in the residual image that is effectively multiplied by the $beam^2$. This means when the noise is determined after the antenna, searching in the optimum domain of $signal/(sigma^2)$. For meter wavelengths where noise is determined by the sky, it is no longer optimal. 

2806 end{description} 

2807 

2808 Input Parameters: 

2809 cyclefactor Cycle threshold = max_resid * min(cyclemaxpsffraction, this * max_sidelobe) 

2810 cyclespeedup Cycle threshold doubles in this number of iterations 

2811 cyclemaxpsffraction Cycle threshold = max_resid * min(this, cyclefactor * max_sidelobe) 

2812 stoplargenegatives Stop the multiscale cycle for the first n cycles when a negative comp is found on the largest scale 

2813 stoppointmode Stop multiscale altogether if the smallest scale recieves this many consecutive components 

2814 minpb Minimum PB level to use 

2815 scaletype Image plane flux scale type 

2816 constpb In Sault weighting the flux scale is constant above this PB level 

2817 fluxscale Names of flux scale images for mosaicing 

2818 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 

2819 

2820 Example: 

2821 

2822 im.setmfcontrol(cyclefactor=2.0, cyclespeedup=niter/10, cyclemaxpsffraction=0.8, 

2823 stoplargenegatives=T, stoppointmode=10, fluxscale='image.fluxscale'); 

2824 

2825 -------------------------------------------------------------------------------- 

2826 

2827 """ 

2828 return _imager.imager_setmfcontrol(self, *args, **kwargs) 

2829 

2830 

2831 def setoptions(self, *args, **kwargs): 

2832 """ 

2833 setoptions(self, _ftmachine, _cache, _tile, _gridfunction, _location, _padding, _freqinterp, _wprojplanes, _epjtablename, _applypointingoffsets, _dopbgriddingcorrections, _cfcachedirname, _rotpastep, _pastep, _pblimit, _imagetilevol, _singleprecisiononly, _numthreads, _psterm, _aterm, _mterm, _wbawp, _conjbeams) -> bool 

2834 

2835 

2836 

2837 Summary: 

2838 Set some general options for subsequent processing 

2839 

2840 Description: 

2841 

2842 

2843 This function is for setting different gridding and memory options 

2844 

2845 begin{description} 

2846 item[ftmachine] The options for ftmachine are: 

2847 begin{description} 

2848 item[ft] Standard interferometric gridding 

2849 item[sd] Standard single dish gridding 

2850 item[both] ft and sd as appropriate. 

2851 item[wproject] option for using the wproject algorithm for wide-field 

2852 imaging; when this option is used the parameter {tt wprojplanes} 

2853 define the number of convolution functions to be used 

2854 item[mosaic] option to use the gridder that uses the primary beam as 

2855 the convolution function in gridding 

2856 

2857 end{description} 

2858 item[cache] The size of the cache used (in complex pixels) during the 

2859 gridding process. The default is to use half the physical memory of 

2860 the machine as specified by the aipsrc variable system.resources.memory. 

2861 item[tile] The side of the tile (in complex pixels) during the 

2862 gridding process. 

2863 item[gridfunction] The gridding function used. Currently only 

2864 Box-car ('BOX') and Prolate Spheriodal Wave Function ('SF') 

2865 are supported. In the case of Single-Dish imaging the Primary Beam ('PB'), 

2866 Gaussian ('GAUSS'), and Gaussian * Jinc ('GJINC') also can be used. 

2867 item[location] For some unusual types of image, one needs to know the 

2868 location to be used in calculating phase rotations. For example, 

2869 one can specify images to be constructed in azel, in which 

2870 case, an antenna position must be chosen. One can use functions of 

2871 measures: either 

2872 observatory to 

2873 get the position of a named observatory ({em e.g.} 

2874 me.observatory('ATCA')) or 

2875 position to set 

2876 the position ({em e.g.}me.position('wgs84','30deg','40deg','10m')). 

2877 Although this information is available from the MeasurementSet, what 

2878 location is ambiguous in some cases {em e.g.} VLBI. 

2879 item[padding] When gridding and transforming, the array may be 

2880 padded by this factor in the image plane. This reduces aliasing, 

2881 especially in wide-field cleaning. 

2882 item[usemodelcol] if this is false it tells imager to create and use the model 

2883 visibility on the fly and in memory as far as possible...otherwise 

2884 if it is True then imager will use the MODEL_DATA column to do this. 

2885 item[wprojplanes] this parameter is is used only of {tt ftmachine} 

2886 is set to {tt wproject}. This defines how many convolution functions 

2887 is used in the Wprojection gridder (a -1 implies an automatic determination). 

2888 end{description} 

2889 

2890 Input Parameters: 

2891 ftmachine Fourier transform machine 

2892 cache Size of gridding cache in complex pixels; default use half the memory available on computer 

2893 tile Size of a gridding tile in pixels (in 1 dimension) 

2894 gridfunction Gridding function 

2895 location Location used in phase rotations 

2896 padding Padding factor in image plane (>=1.0) 

2897 freqinterp interpolation mode in frequency;options:- nearest, linear, cubic, spline 

2898 wprojplanes No of gridding convolution functions used in wproject-ft machine (-1 means let the code decide this number) 

2899 epjtablename E-Jones table name. This is used if applypointingoffsets is set to True. 

2900 applypointingoffsets Apply pointing offset corrections during deconvolution. 

2901 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. 

2902 cfcachedirname Directory where convolution functions are to be (or are being ) cached on the disk. 

2903 rotpastep The PA increment in degree used for on-the-fly (OTF) rotation of the A-term in A-Projection. 

2904 pastep The PA increment in degree used to compute the PA-rotated A-term in A-Projection. 

2905 pblimit Primary beam limit when using PBWProjection 

2906 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 (0) implies 32x32x4x32 tile shape. Setting it explicitly to a negative number will also try to avoid using disk templattices when possible.  

2907 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  

2908 numthreads Limit the number of threads used in this run (openmp enabled only) 

2909 psterm Switch-on the PS-Term? 

2910 aterm Switch-on the A-Term? 

2911 mterm Switch-on the M-Term? 

2912 wbawp Trigger the WB A-Projection algorithm? 

2913 conjbeams Use frequency conjugate beams in WB A-Projection algorithm? 

2914 

2915 Example: 

2916 

2917 - im.setoptions(cache=10000000, tile=32, gridfunction='BOX', 

2918 location=me.location('vla')) 

2919 

2920 The above example is to tell imager to use memory to fit 10000000 

2921 complex numbers and tile the image with tiles of 32 pixels on a side. 

2922 Also it tells imager to use a box function as gridding function. The 

2923 location parameter will make imager overide the position of the 

2924 telescope to use (the default is the one it gets from the ms). 

2925 

2926 

2927 im.open('n1333.ms') 

2928 im.selectvis(fieldid=[2:6, 8:12], spwid=[1:2]) 

2929 im.defineimage(nx=800, ny=800, cellx='0.5arcsec', celly='0.5arcsec', mode='velocity', nchan=30, mstart='-10km/s', mstep='1.8km/s', spwid=[1,2],fieldid=3) 

2930 im.setoptions(ftmachine='mosaic') 

2931 im.setvp(dovp=T) 

2932 im.setoptions(ftmachine='mosaic') 

2933 im.clean(algorithm='mfclark', model='try1', niter=200) 

2934 

2935 

2936 

2937 In the above example we are making a mosaic using the fields 

2938 2,3,4,5,6,8,9,10,11,12 and we use the mosaic ftmachine. This uses the 

2939 primary beam of the telescope as the gridding function. 

2940 

2941 

2942 im.open('coma.ms') 

2943 im.selectvis(spwid=1, fieldid=1); 

2944 mydir=me.direction('J2000', '12h30m48', '12d24m0') 

2945 im.defineimage(nx=200, cellx='30arcsec', phasecenter=mydir); 

2946 im.make('outlier1'); 

2947 im.defineimage(nx=1800, cellx='30arcsec'); 

2948 im.setoptions(ftmachine='wproject',wprojplanes=512, padding=1.0) 

2949 im.make('main') 

2950 im.clean(algorithm='mfclark',model=['main', 'outlier1'], niter=10000, image=['coma.image', 'outlier1.image']) 

2951 im.done() 

2952 

2953 

2954 

2955 In the above example we are using the Wprojection algorithm for 3-D 

2956 imaging. We are using 512 gridding functions. Sometimes if there is a 

2957 memory issue (very large images and many griding functions) we suggest 

2958 the use of facetting of the image with wprojection. So the example 

2959 above would be something like below. Note that when using facets only 

2960 the {tt wfclark} and {tt wfhogbom} can be used for now. Note on how 

2961 an outlier field (or flanking) field is set on an interfering source 

2962 outside of the field of interest. 

2963 

2964 

2965 im.open('coma.ms') 

2966 

2967 im.selectvis(spwid=1, fieldid=1); 

2968 mydir = me.direction('J2000', '12h30m48', '12d24m0') 

2969 im.defineimage(nx=200, ny=200, cellx='30arcsec', celly='30arcsec', phasecenter=mydir); 

2970 im.make('outlier1'); 

2971 im.defineimage(nx=3000, ny=3000, cellx='30arcsec',celly='30arcsec',facets=3); 

2972 im.setoptions(ftmachine='wproject',wprojplanes=200, padding=1.2) 

2973 im.make('main') 

2974 im.clean(algorithm='wfclark',model=['main', 'outlier1'], niter=10000) 

2975 im.done() 

2976 

2977 -------------------------------------------------------------------------------- 

2978 

2979 """ 

2980 return _imager.imager_setoptions(self, *args, **kwargs) 

2981 

2982 

2983 def setscales(self, *args, **kwargs): 

2984 """ 

2985 setscales(self, _scalemethod, _nscales, _uservector) -> bool 

2986 

2987 

2988 

2989 Summary: 

2990 Set the scale sizes for MultiScale Clean 

2991 

2992 Description: 

2993 

2994 

2995 

2996 The multiscale clean algorithm cleans an image on a number of 

2997 different scales, decomposing the image into Gaussians of these scale sizes. 

2998 This function allows the user to set the number 

2999 of scales used (using the nscales method), or to directly control the 

3000 sizes of the scales in pixels (using the uservector method). When using the 

3001 nscales method, the scales are calculated using the following formula: 

3002 begin{equation} 

3003 theta_{minor} 10.0 ^{(i- N_{scales}/2)/2.0} 

3004 end{equation} 

3005 where $theta_{min}$ is the fitted minor axis of the clean beam. The 

3006 first value is zero. 

3007 

3008 Input Parameters: 

3009 scalemethod Method by which scales are set 

3010 nscales Number of scales 

3011 uservector Vector of scale sizes in pixels to use, defaults should be 0,3,10  

3012 

3013 Example: 

3014 

3015 - im.setscales(scalemethod='nscales', nscales=6); 

3016 

3017 Here we make six scales automatically using the method described 

3018 above. 

3019 Or we could manually choose the scales in pixel numbers as follows: 

3020 

3021 - im.setscales(scalemethod='uservector', uservector=[0,3,10,30]); 

3022 

3023 

3024 Note: 0 pixel is the delta function, so if one were to select scale 0 only 

3025 it would be equivalent to a Hogbom clean. 

3026 

3027 -------------------------------------------------------------------------------- 

3028 

3029 """ 

3030 return _imager.imager_setscales(self, *args, **kwargs) 

3031 

3032 

3033 def setsmallscalebias(self, *args, **kwargs): 

3034 """ 

3035 setsmallscalebias(self, _inbias) -> bool 

3036 

3037 

3038 

3039 Summary: 

3040 Set bias toward smaller scales for MultiScale Clean 

3041 

3042 Input Parameters: 

3043 inbias small scale bias 

3044 

3045 Example: 

3046 

3047 - im.setsmallscalebias(inbias=0.6); 

3048 

3049 -------------------------------------------------------------------------------- 

3050 

3051 """ 

3052 return _imager.imager_setsmallscalebias(self, *args, **kwargs) 

3053 

3054 

3055 def settaylorterms(self, *args, **kwargs): 

3056 """ 

3057 settaylorterms(self, _ntaylorterms, _reffreq) -> bool 

3058 

3059 

3060 

3061 Summary: 

3062 Set the number of Taylor series terms for Multi-Frequency Clean 

3063 

3064 Description: 

3065 

3066 

3067 

3068 The multi-frequency clean algorithm cleans an image by approximating its spectra 

3069 by a Taylor series expansion. This function allows the user to set the number of 

3070 Taylor terms to be used. Options are 1,2,3. 

3071 

3072 Input Parameters: 

3073 ntaylorterms Number of Taylor terms 

3074 reffreq Reference Frequency 

3075 

3076 Example: 

3077 

3078 - im.settaylorterms(ntaylorterms=3); 

3079 

3080 -------------------------------------------------------------------------------- 

3081 

3082 """ 

3083 return _imager.imager_settaylorterms(self, *args, **kwargs) 

3084 

3085 

3086 def setsdoptions(self, *args, **kwargs): 

3087 """ 

3088 setsdoptions(self, _scale, _weight, _convsupport, _pointingcolumntouse, _truncate, _gwidth, _jwidth, _minweight, _clipminmax, _enablecache, _convertfirst) -> bool 

3089 

3090 

3091 

3092 Summary: 

3093 Set some options for single dish processing 

3094 

3095 Description: 

3096 

3097 

3098 Various less-often-used options for single dish processing can be set. 

3099 

3100 begin{description} 

3101 item[scale] The overall scale of the single dish data is multiplied by this 

3102 factor. 

3103 item[weight] The weight given to the single dish data in the imaging 

3104 is multiplied by this factor. 

3105 item[convsupport] This parameter can be used to change the support used in gridding single dish data in imaging. If 'PB' or 'pb' is used as the 'convtype' in 

3106 setoptions this parameter is ignored as the support is defined by the primary beam. The deafult of -1 mans 1 as convsupport is used for 'box' convolution function and 3 is used for 'SF' convolution function. 

3107 item[pointingcolumntouse] This parameter is NOT to be changed under normal circumstances. This is to be used by those who know what they are doing and want to try to use different columns in the POINTING table especially if they believe their dish direction is wrong. And if any of the {tt _OFFSET} columns is used do not expect to be able to use a different frame in the image setup in defineimage. Possible values are {tt DIRECTION, TARGET, ENCODER, POINTING_OFFSET, SOURCE_OFFSET} 

3108 item[truncate] The truncation radius as a quantity or a float value. This parameter is effective only when 'GAUSS' or 'GJINC' is used as the 'convtype' in setoptions. You can use an unit 'pixel' to specify truncation radius as pixel value. If float value is set, or quantity without unit is set, its unit will be 'pixel'. 

3109 item[gwidth] The width of the gaussian beam as a radius of half maximum. This parameter is effective only when 'GAUSS' or 'GJINC' is used as the 'convtype' in setoptions. You can use an unit 'pixel' to specify truncation radius as pixel value. If float value is set, or quantity without unit is set, its unit will be 'pixel'. Note that, when 'GJINC' is used as the 'convtype', gwidth doesn't directry specify width of the convolution function. 

3110 item[jwidth] The witdh of the jinc beam as a parameter c, where jinc = J_1(pi*x/c)/(pi*x/c). This parameter is effective only when 'GJINC' is used as the 'convtype' in setoptions. You can use an unit 'pixel' to specify truncation radius as pixel value. If float value is set, or quantity without unit is set, its unit will be 'pixel'. Note that jwidth doesn't directly specify width of the convolution function. 

3111 end{description} 

3112 

3113 Input Parameters: 

3114 scale Scaling applied to single dish data 

3115 weight Weights applied to single dish data 

3116 convsupport number of pixel for convolution support 

3117 pointingcolumntouse Which Pointing Table column to use to get direction 

3118 truncate truncation radius (effective only for 'GAUSS' or 'GJINC') 

3119 gwidth radius of half maximum for gaussian (effective only for 'GAUSS' or 'GJINC') 

3120 jwidth c-parameter for jinc function (effective only for 'GJINC') 

3121 minweight Minimum weight level to use for weight correction and weight based masking. 

3122 clipminmax Clip minimum and maximum values from each grid 

3123 enablecache Cache spectra pixel coordinates for later re-use 

3124 convertfirst Interpolation-Conversion scheme to use: convert pointingcolumntouse before performing interpolation at data-taking time 

3125 

3126 Example: 

3127 

3128 - im.setsdoptions(scale=1.0, weight=1.0, convsupport=5) 

3129 

3130 -------------------------------------------------------------------------------- 

3131 

3132 """ 

3133 return _imager.imager_setsdoptions(self, *args, **kwargs) 

3134 

3135 

3136 def setvp(self, *args, **kwargs): 

3137 """ 

3138 setvp(self, _dovp, _usedefaultvp, _vptable, _dosquint, _parangleinc, _skyposthreshold, _telescope, _verbose) -> bool 

3139 

3140 

3141 

3142 Summary: 

3143 Set the voltage pattern model for subsequent processing 

3144 

3145 Description: 

3146 

3147 

3148 Set the voltage pattern model (and hence, the primary beam) used for a 

3149 telescope. There are currently two ways to set the voltage pattern: by using 

3150 the extensive list of defaults which the system knows about, or by creating a 

3151 voltage pattern description with the vpmanager. The default voltage patterns 

3152 include both a high and a low frequency VP for the WSRT, a VP for each 

3153 observing band at the AT, several VP's for the VLA, including the appropriate 

3154 beam squint for each observing band, and Gaussian for the BIMA dishes. Due to 

3155 temporary limitations in the internal structure of the visibility buffer, only 

3156 one telescope's voltage pattern can be applied to a particular MeasurementSet. 

3157 This will be corrected shortly. 

3158 

3159 Input Parameters: 

3160 dovp Do voltage pattern (ie, primary beam) correction 

3161 usedefaultvp Look up the default VP for this telescope and frequency? 

3162 vptable If usedefaultvp is False, provide a VP Table made with vpmanager 

3163 dosquint Activate the beam squint in the VP model 

3164 parangleinc Parallactice angle increment for squint application 

3165 skyposthreshold Sky position threshold  

3166 telescope Which default telescope to use; if empty use the one in encoded in MS 

3167 verbose If false, suppress some messages from being sent to the logger. 

3168 

3169 Example: 

3170 

3171 im.setvp(dovp=True, usedefaultvp=True, dosquint=False) 

3172 

3173 -------------------------------------------------------------------------------- 

3174 

3175 """ 

3176 return _imager.imager_setvp(self, *args, **kwargs) 

3177 

3178 

3179 def setweightgrid(self, *args, **kwargs): 

3180 """ 

3181 setweightgrid(self, _weight, _type) -> bool 

3182 

3183 

3184 

3185 Summary: 

3186 set the requested weight grids 

3187 

3188 Description: 

3189 

3190 

3191 

3192 This is a utility function when running multi imager processes in parallel on subsection of an ms/data independently 

3193 One would wish to weight the dirty image before averaging or set the imaging weight density (when using unform or 

3194 Brigg's style weighting) to account for all the data being used. This is {bf NOT} for the general user but for people who 

3195 are parallelizing at the scripting level. 

3196 

3197 Input Parameters: 

3198 weight Numeric array. Required input. 

3199 type Type of weight requested 

3200 

3201 Example: 

3202 

3203 wght=im.getweightgrid('imaging') 

3204 wght2=im2.getweightgrid('imaging') 

3205 wght=wght+wght2 

3206 

3207 im.setweightgrid(weight=wght, type='imaging') 

3208 im2.setweightgrid(weight=wght, type='imaging') 

3209 

3210 -------------------------------------------------------------------------------- 

3211 

3212 """ 

3213 return _imager.imager_setweightgrid(self, *args, **kwargs) 

3214 

3215 

3216 def smooth(self, *args, **kwargs): 

3217 """ 

3218 smooth(self, _model, _image, _usefit, _bmaj, _bmin, _bpa, _normalize) -> bool 

3219 

3220 

3221 

3222 Summary: 

3223 Calculate an image smoothed with a Gaussian beam 

3224 

3225 Description: 

3226 

3227 

3228 The model images are convolved with the specified Gaussian beam. By 

3229 default (normalize=T), the beam volume is normalized to unity so that 

3230 the smoothing is flux preserving. The smoothing used in restoration is 

3231 not normalized. 

3232 

3233 Input Parameters: 

3234 model Name of input model 

3235 image Name of output smoothed images 

3236 usefit Use the fitted value (rather than that specified 

3237 bmaj Major axis of beam 

3238 bmin Minor axis of beam 

3239 bpa Position angle of beam 

3240 normalize Normalize volume of psf to unity 

3241 

3242 Example: 

3243 

3244 - im.smooth(model='3C273XC1.clean', image='3C273XC1.clean.restored', 

3245 bmaj='2.0arcsec', bmin='2.0arcsec') 

3246 

3247 -------------------------------------------------------------------------------- 

3248 

3249 """ 

3250 return _imager.imager_smooth(self, *args, **kwargs) 

3251 

3252 

3253 def stop(self): 

3254 """ 

3255 stop(self) -> bool 

3256 

3257 

3258 

3259 Summary: 

3260 stop the currently executing function asap 

3261 

3262 Description: 

3263 

3264 

3265 Stop the currently executing function as soon as possible. Note that 

3266 it is not always possible to stop a function. 

3267 

3268 -------------------------------------------------------------------------------- 

3269 

3270 """ 

3271 return _imager.imager_stop(self) 

3272 

3273 

3274 def summary(self): 

3275 """ 

3276 summary(self) -> bool 

3277 

3278 

3279 

3280 Summary: 

3281 Summarize the current state of the imager tool 

3282 

3283 Description: 

3284 

3285 

3286 Writes a summary of the properties of the imager to the 

3287 default logger. This includes: 

3288 begin{itemize} 

3289 item The name of the MeasurementSet (set in construction or via the 

3290 open function. 

3291 item The parameters of the image (set via defineimage) 

3292 item The current beam (set by fitpsf 

3293 or setbeam. 

3294 item The selection of an ms (set via selectvis) 

3295 item The general processing options (set via setoptions) 

3296 end{itemize} 

3297 

3298 Example: 

3299 

3300 - im.open('3C273XC1.MS'); 

3301 - im.defineimage(nx=256, ny=256) 

3302 - im.summary() 

3303 

3304 -------------------------------------------------------------------------------- 

3305 

3306 """ 

3307 return _imager.imager_summary(self) 

3308 

3309 

3310 def uvrange(self, *args, **kwargs): 

3311 """ 

3312 uvrange(self, _uvmin, _uvmax) -> bool 

3313 

3314 

3315 

3316 Summary: 

3317 Select data within the limit of a given range 

3318 

3319 Description: 

3320 

3321 

3322 Apply a uvrange so that only points within a given uvrange are selected for further usage. To be noted selectvis if used after uvrange will reset the selected range. So selectvis should be used prior to uvrange or can be used 

3323 

3324 to reset it if one changes one's mind. The points are not flagged! Further point to be noted for spectral line data the uv distance is calculated using the mean of the wavelengths of the different spectral channels selected. 

3325 

3326 Input Parameters: 

3327 uvmin Minimum uv distance allowed (wavelengths) 

3328 uvmax Maximum uv distance allowed (wavelengths) 

3329 

3330 Example: 

3331 

3332 im.weight('uniform') 

3333 im.uvrange(0, 4000.0) 

3334 

3335 -------------------------------------------------------------------------------- 

3336 

3337 """ 

3338 return _imager.imager_uvrange(self, *args, **kwargs) 

3339 

3340 

3341 def weight(self, *args, **kwargs): 

3342 """ 

3343 weight(self, _type, _rmode, _noise, _robust, _fieldofview, _npixels, _mosaic) -> bool 

3344 

3345 

3346 

3347 Summary: 

3348 Apply additional weighting to the visibility weights 

3349 

3350 Description: 

3351 

3352 

3353 Apply visibility weighting to correct for the local density of 

3354 sampling in the uv plane. The imaging weights are calculated on the fly 

3355 when processing the data and can be viewed by 

3356 plotweights. 

3357 

3358 To correct for visibility sampling effects, natural, uniform, radial, and Briggs weighting are supported. These work as 

3359 follows. Then: 

3360 begin{description} 

3361 item[natural]: minimizes the noise in the dirty image. The weight of 

3362 the $i$-th sample is set to the inverse variance: 

3363 begin{equation} 

3364 w_i={1over{sigma_i^2}} 

3365 end{equation} 

3366 where $sigma_i$ is the noise of the $i$'th sample. 

3367 item[radial]: approximately minimizes rms sidelobes for an east-west synthesis 

3368 array. The weight of the $i$-th sample is multiplied 

3369 by the radial distance from the center of the $u,v$ plane: 

3370 begin{equation} 

3371 w_i=w_i sqrt{u_i^2+v_i^2} 

3372 end{equation} 

3373 item[uniform]: For Briggs and uniform weighting, we first grid the inverse 

3374 variance $w_i$ for all selected data onto a grid of size given by the 

3375 argument npixels (default to nx) and u,v cell-size given by 

3376 $2/$fieldofview where fieldofview is the specified field of view 

3377 (defaults to the image field of view). This forms the gridded weights 

3378 $W_k$. The weight of the $i$-th sample is then changed: 

3379 begin{equation} 

3380 w_i={w_iover{W_k}} 

3381 end{equation} 

3382 where $W_k$ is the gridded weight of the relevant cell. 

3383 It may be shown that this minimizes rms sidelobes over 

3384 the field of view. By changing the field of view, one may suppress 

3385 the sidelobes over a region different (usually smaller) than the 

3386 image size. 

3387 item[briggs: rmode='norm']: The weights are changed: 

3388 begin{equation} 

3389 w_i={w_iover{1 + W_k f^2}} 

3390 end{equation} 

3391 where: 

3392 begin{equation} 

3393 f^2={{(5*10^{-R})^2}over{{sum_k W_k^2}over{sum_i w_i}}} 

3394 end{equation} 

3395 and $R$ is the robust parameter. The scaling of $R$ is such that 

3396 $R=0$ gives a good tradeoff between resolution and sensitivity. 

3397 $R$ takes value between -2.0 (close to uniform weighting) to 2.0 

3398 (close to natural). 

3399 item[briggs: rmode='abs']: The weights are changed: 

3400 begin{equation} 

3401 w_i={w_iover{W_k*R^2+2*sigma_R^2}} 

3402 end{equation} 

3403 where $R$ is the robust parameter and $sigma_R$ is the noise 

3404 parameter. 

3405 end{description} 

3406 For more details about Briggs (aka robust) weighting, see the htmladdnormallink{Briggs thesis} 

3407 {briggsURL}. 

3408 

3409 Note that this weighting is {em not} cumulative since the imaging weights are 

3410 calculated from the specified weight (function of noise; usually $1/sigma^2$) per visibility 

3411 (actually stored in the WEIGHT column). 

3412 

3413 Input Parameters: 

3414 type Type of weighting 

3415 rmode Mode of briggs weighting 

3416 noise Noise used in absolute briggs weighting 

3417 robust Parameter in briggs weighting 

3418 fieldofview Field of view for uniform weighting 

3419 npixels Number of pixels in the u and v directions 

3420 mosaic Individually weight the fields of a mosaic 

3421 

3422 Example: 

3423 

3424 im.weight(type='briggs', rmode='norm', robust=0.5) 

3425 

3426 

3427 Applies Briggs (robust) weighting. 

3428 

3429 -------------------------------------------------------------------------------- 

3430 

3431 """ 

3432 return _imager.imager_weight(self, *args, **kwargs) 

3433 

3434 

3435 def mapextent(self, *args, **kwargs): 

3436 """ 

3437 mapextent(self, _ref, _movingsource, _pointingcolumntouse) -> record * 

3438 

3439 

3440 

3441 Summary: 

3442 Compute map extent from given set of MSs 

3443 

3444 Description: 

3445 

3446 

3447 TODO: description must be filled 

3448 

3449 Input Parameters: 

3450 ref direction reference 

3451 movingsource moving source name 

3452 pointingcolumntouse POINTING table column to be used for computation 

3453 

3454 Example: 

3455 

3456 TODO: example must be filled. 

3457 

3458 -------------------------------------------------------------------------------- 

3459 

3460 """ 

3461 return _imager.imager_mapextent(self, *args, **kwargs) 

3462 

3463 

3464 def pointingsampling(self, *args, **kwargs): 

3465 """ 

3466 pointingsampling(self, _pattern, _ref, _movingsource, _pointingcolumntouse, _antenna) -> record * 

3467 

3468 

3469 

3470 Summary: 

3471 Calculate Sampling interval of an MS 

3472 

3473 Description: 

3474 

3475 

3476 Calculate sampling interval of an MS. 

3477 

3478 Input Parameters: 

3479 pattern scan pattern (NOTE: only raster is supported so far) 

3480 ref direction reference 

3481 movingsource moving source name 

3482 pointingcolumntouse POINTING table column to be used for computation 

3483 antenna Additional antenna selection 

3484 

3485 Example: 

3486 

3487 im.open(msname) 

3488 im.selectvis(spw='17', field='M100', intent='OBSERVE_TARGET#ON_SOURCE') 

3489 im.pointingsampling(pattern='raster', ref='J2000', antenna='PM03&&&') 

3490 # returns a dictionary of sampling and angle, e.g., 

3491 # {'angle': {'unit': 'rad', 'value': -0.00014148390015604565}, 

3492 # 'sampling': {'unit': 'rad', 

3493 # 'value': array([ 1.23216297e-05, 0.00000000e+00])}} 

3494 im.close() 

3495 

3496 -------------------------------------------------------------------------------- 

3497 

3498 """ 

3499 return _imager.imager_pointingsampling(self, *args, **kwargs) 

3500 

3501 __swig_destroy__ = _imager.delete_imager 

3502 __del__ = lambda self: None 

3503 __swig_setmethods__["_pixels_advise"] = _imager.imager__pixels_advise_set 

3504 __swig_getmethods__["_pixels_advise"] = _imager.imager__pixels_advise_get 

3505 if _newclass: 

3506 _pixels_advise = _swig_property(_imager.imager__pixels_advise_get, _imager.imager__pixels_advise_set) 

3507 __swig_setmethods__["_cell_advise"] = _imager.imager__cell_advise_set 

3508 __swig_getmethods__["_cell_advise"] = _imager.imager__cell_advise_get 

3509 if _newclass: 

3510 _cell_advise = _swig_property(_imager.imager__cell_advise_get, _imager.imager__cell_advise_set) 

3511 __swig_setmethods__["_facets_advise"] = _imager.imager__facets_advise_set 

3512 __swig_getmethods__["_facets_advise"] = _imager.imager__facets_advise_get 

3513 if _newclass: 

3514 _facets_advise = _swig_property(_imager.imager__facets_advise_get, _imager.imager__facets_advise_set) 

3515 __swig_setmethods__["_phasecenter_advise"] = _imager.imager__phasecenter_advise_set 

3516 __swig_getmethods__["_phasecenter_advise"] = _imager.imager__phasecenter_advise_get 

3517 if _newclass: 

3518 _phasecenter_advise = _swig_property(_imager.imager__phasecenter_advise_get, _imager.imager__phasecenter_advise_set) 

3519 __swig_setmethods__["_bmaj_fitpsf"] = _imager.imager__bmaj_fitpsf_set 

3520 __swig_getmethods__["_bmaj_fitpsf"] = _imager.imager__bmaj_fitpsf_get 

3521 if _newclass: 

3522 _bmaj_fitpsf = _swig_property(_imager.imager__bmaj_fitpsf_get, _imager.imager__bmaj_fitpsf_set) 

3523 __swig_setmethods__["_bmin_fitpsf"] = _imager.imager__bmin_fitpsf_set 

3524 __swig_getmethods__["_bmin_fitpsf"] = _imager.imager__bmin_fitpsf_get 

3525 if _newclass: 

3526 _bmin_fitpsf = _swig_property(_imager.imager__bmin_fitpsf_get, _imager.imager__bmin_fitpsf_set) 

3527 __swig_setmethods__["_bpa_fitpsf"] = _imager.imager__bpa_fitpsf_set 

3528 __swig_getmethods__["_bpa_fitpsf"] = _imager.imager__bpa_fitpsf_get 

3529 if _newclass: 

3530 _bpa_fitpsf = _swig_property(_imager.imager__bpa_fitpsf_get, _imager.imager__bpa_fitpsf_set) 

3531 __swig_setmethods__["_pointsource_sensitivity"] = _imager.imager__pointsource_sensitivity_set 

3532 __swig_getmethods__["_pointsource_sensitivity"] = _imager.imager__pointsource_sensitivity_get 

3533 if _newclass: 

3534 _pointsource_sensitivity = _swig_property(_imager.imager__pointsource_sensitivity_get, _imager.imager__pointsource_sensitivity_set) 

3535 __swig_setmethods__["_relative_sensitivity"] = _imager.imager__relative_sensitivity_set 

3536 __swig_getmethods__["_relative_sensitivity"] = _imager.imager__relative_sensitivity_get 

3537 if _newclass: 

3538 _relative_sensitivity = _swig_property(_imager.imager__relative_sensitivity_get, _imager.imager__relative_sensitivity_set) 

3539 __swig_setmethods__["_sumweights_sensitivity"] = _imager.imager__sumweights_sensitivity_set 

3540 __swig_getmethods__["_sumweights_sensitivity"] = _imager.imager__sumweights_sensitivity_get 

3541 if _newclass: 

3542 _sumweights_sensitivity = _swig_property(_imager.imager__sumweights_sensitivity_get, _imager.imager__sumweights_sensitivity_set) 

3543 __swig_setmethods__["_senrec_sensitivity"] = _imager.imager__senrec_sensitivity_set 

3544 __swig_getmethods__["_senrec_sensitivity"] = _imager.imager__senrec_sensitivity_get 

3545 if _newclass: 

3546 _senrec_sensitivity = _swig_property(_imager.imager__senrec_sensitivity_get, _imager.imager__senrec_sensitivity_set) 

3547 __swig_setmethods__["_pointsource_apparentsens"] = _imager.imager__pointsource_apparentsens_set 

3548 __swig_getmethods__["_pointsource_apparentsens"] = _imager.imager__pointsource_apparentsens_get 

3549 if _newclass: 

3550 _pointsource_apparentsens = _swig_property(_imager.imager__pointsource_apparentsens_get, _imager.imager__pointsource_apparentsens_set) 

3551 __swig_setmethods__["_relative_apparentsens"] = _imager.imager__relative_apparentsens_set 

3552 __swig_getmethods__["_relative_apparentsens"] = _imager.imager__relative_apparentsens_get 

3553 if _newclass: 

3554 _relative_apparentsens = _swig_property(_imager.imager__relative_apparentsens_get, _imager.imager__relative_apparentsens_set) 

3555imager_swigregister = _imager.imager_swigregister 

3556imager_swigregister(imager) 

3557cvar = _imager.cvar 

3558 

3559# This file is compatible with both classic and new-style classes. 

3560 

3561