Coverage for /wheeldirectory/casa-6.7.2-31-py3.12.el8/lib/py/lib/python3.12/site-packages/casatools/__casac__/calibrater.py: 58%
166 statements
« prev ^ index » next coverage.py v7.10.1, created at 2025-07-31 10:44 +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.
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, '_calibrater')).lstrip('.')
13 try:
14 return importlib.import_module(mname)
15 except ImportError:
16 return importlib.import_module('_calibrater')
17 _calibrater = 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('_calibrater', [dirname(__file__)])
26 except ImportError:
27 import _calibrater
28 return _calibrater
29 try:
30 _mod = imp.load_module('_calibrater', fp, pathname, description)
31 finally:
32 if fp is not None:
33 fp.close()
34 return _mod
35 _calibrater = swig_import_helper()
36 del swig_import_helper
37else:
38 import _calibrater
39del _swig_python_version_info
41try:
42 _swig_property = property
43except NameError:
44 pass # Python < 2.2 doesn't have 'property'.
46try:
47 import builtins as __builtin__
48except ImportError:
49 import __builtin__
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)
70def _swig_setattr(self, class_type, name, value):
71 return _swig_setattr_nondynamic(self, class_type, name, value, 0)
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))
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,)
90try:
91 _object = object
92 _newclass = 1
93except __builtin__.Exception:
94 class _object:
95 pass
96 _newclass = 0
98class calibrater(_object):
99 """Proxy of C++ casac::calibrater class."""
101 __swig_setmethods__ = {}
102 __setattr__ = lambda self, name, value: _swig_setattr(self, calibrater, name, value)
103 __swig_getmethods__ = {}
104 __getattr__ = lambda self, name: _swig_getattr(self, calibrater, name)
105 __repr__ = _swig_repr
107 def __init__(self):
108 """__init__(self) -> calibrater"""
109 this = _calibrater.new_calibrater()
110 try:
111 self.this.append(this)
112 except __builtin__.Exception:
113 self.this = this
115 def open(self, *args, **kwargs):
116 """
117 open(self, _filename, _compress, _addcorr, _addmodel) -> bool
121 Summary:
122 Attach MeasurementSet to the calibrater tool
124 Description:
127 Attaches a MeasurementSet to the {tt calibrater} tool for further processing with
128 other methods.
130 Input Parameters:
131 filename MeasurementSet file name. No default
132 compress Compress calibration columns?
133 addcorr Add scratch columns?
134 addmodel Add MODEL_DATA column along with CORRECTED_DATA ?
136 Example:
138 cb.open('ngc5921.ms');
140 --------------------------------------------------------------------------------
142 """
143 return _calibrater.calibrater_open(self, *args, **kwargs)
146 def selectvis(self, *args, **kwargs):
147 """
148 selectvis(self, _time, _spw, _scan, _field, _intent, _observation, _baseline, _uvrange, _chanmode, _nchan, _start, _step, _mstart, _mstep, _msselect) -> bool
152 Summary:
153 Set the data selection for subsequent processing
155 Description:
159 This function provids for selection of the visibility data from the MS
160 which will be treated by subsequent execution of the {stfaf solve} and
161 {stfaf correct} functions. Note that data selection is not cumulative, i.e.,
162 any selection made in a previous call to {stfaf selectvis} will be overridden
163 by the the current call.
165 Most of the {stfaf selectvis} parameters use the standardized MS Selection
166 syntax.
168 The parameters are described below. The selected data will satisfy the
169 logical AND of all non-trivially specified parameters. Note that the
170 old-fashioned strided channel selection parameters are deprecated (and
171 will soon be removed); use spw instead. Running {stfaf selectvis} with
172 no specified parameters restores selection of the entire MS.
175 begin{description}
176 item[time] is used to specify time ranges in a stardard format
178 item[spw] is used to specify spectral window and channel selection. Currently,
179 only a single channel range can be specified per spw.
181 item[scan] is used to specify scan numbers and ranges
183 item[observation] is used to specify observation ID(s).
185 item[field] is used to specify field names or indices
187 item[baseline] is used to specify antenna and baseline combinations
189 item[uvrange] is used to specify baseline length ranges
191 item[chanmode] is deprecated (use spw)
192 item[nchan] is deprecated (use spw)
193 item[start] is deprecated (use spw)
194 item[step] is deprecated (use spw)
195 item[mstart] is deprecated (use spw)
196 item[mstep] is deprecated (use spw)
198 item[msselect] is used to specify a subselection of data according to
199 Measurement Set columns in conditional combinations not possible
200 with the standard parameters above. This parameter should be specified
201 as a valid htmladdnormallink{TaQL}{../../notes/199/199.html} expression.
202 If both msselect and the standard selection parameter are used together,
203 they are combined with a logical AND, i.e., the data must jointly satisfy
204 all {stfaf selectvis} parameters.
206 end{description}
208 Input Parameters:
209 time Select on time
210 spw Select on spectral window
211 scan Select on scan
212 field Select on field
213 intent Select on intent or state
214 observation Select by observation ID(s)
215 baseline Select on antennas/baselines
216 uvrange Select by uvrange
217 chanmode Type of data selection: channel or velocity
218 nchan Number of channels to select (mode='channel')
219 start Start channel (0-relative) (mode='channel')
220 step Step in channel number (mode='channel')
221 mstart Start velocity (e.g. '20Km/s')
222 mstep Step in velocity (e.g. '100m/s')
223 msselect TAQL selection string. Default (empty) is no specific selection.
225 Example:
227 Open and select a field:
230 cb.open('ngc5921.ms');
231 cb.selectvis(field='N5921_2'); # by complete name
232 cb.selectvis(field='N5921*'); # with wildcard
233 cb.selectvis(field='2'); # by index
236 Select a field and a channel range:
239 cb.selectvis(spw='0:10~40',field='N5921*');
242 Select using all MS Selection parameters (these parameters are
243 over-specified somewhat, i.e., scan 6 contains only field N5921_2,
244 etc.):
247 cb.selectvis(time='>1995/04/13/10:40:00', # times greater than this
248 spw='0:20~40', # channels 20-40 in spw 0
249 scan='6', # scan 6 only
250 field='N59*', # fields matching N59*
251 baseline='1 & *', # baselines to antenna 1
252 uvrange='>0.0klambda') # baselines greater than zero length
256 Reset selection to the entire dataset
259 cb.selectvis()
261 --------------------------------------------------------------------------------
263 """
264 return _calibrater.calibrater_selectvis(self, *args, **kwargs)
267 def setmodel(self, *args, **kwargs):
268 """
269 setmodel(self, _modelimage) -> bool
273 Summary:
274 Set the sky model used to compute the model visibilities
276 Description:
279 Name of the model image to be used as a sky model for model visibility
280 computations. For now, this is used only by EP-Jones solver.
282 Input Parameters:
283 modelimage Name of the model image.
285 Example:
287 cb.setmodel('mymodel');
289 --------------------------------------------------------------------------------
291 """
292 return _calibrater.calibrater_setmodel(self, *args, **kwargs)
295 def setptmodel(self, *args, **kwargs):
296 """
297 setptmodel(self, _stokes) -> bool
301 Summary:
302 Set the point source model Stokes parameters to be used to compute the model visibilities
304 Description:
307 Set a global point source model Stokes parameters to use in solving operations.
309 Input Parameters:
310 stokes Vector of Stokes parameters.
312 Example:
314 cb.setmodel([1,1,0,0]);
316 --------------------------------------------------------------------------------
318 """
319 return _calibrater.calibrater_setptmodel(self, *args, **kwargs)
322 def setapply(self, *args, **kwargs):
323 """
324 setapply(self, _type, _t, _table, _field, _interp, _select, _calwt, _spwmap, _opacity) -> bool
328 Summary:
329 Arrange to apply calibration
331 Description:
335 This function is used to specify the calibration components which should be
336 applied during subsequent execution of the {stfaf solve} and
337 {stfaf correct} functions. This function should be executed as many
338 times as necessary to specify all desired calibration components.
340 Each calibration component represents a separate calibration matrix
341 correction included in the measurement equation. The different types
342 correspond to different instrumental and atmospheric effects.
343 Calibration components are available as calibration tables generated
344 by previous {stfaf solve} executions (types 'B','BPOLY','G','GSPLINE',
345 'D','DF','T','M','MF','X'), or are calculated analytically on
346 the fly (types 'P', 'TOPAC', 'GAINCURVE'). Upon execution
347 of {stfaf solve} or {stfaf correct}, the group of specified
348 calibration components will be applied in the order prescribed
349 by the Measurement Equation formalism.
351 The parameters are as follows:
353 begin{description}
355 item[type] The calibration type being specified. This is only required
356 for analytic types ('P','TOPAC','GAINCURVE'). When specifying an existing
357 pre-solved calibration table, it is not necessary to explicitly specify the
358 {stfaf type}; this will be discerned from the table. (Specifying the
359 {stfaf type} as well as the {stfaf table} will force a check that the
360 table contains solutions of the specified type.
362 For {stfaf type='GAINCURVE'}, an elevation-dependent correction
363 will be applied using parameters read from the data repository.
364 Currently, this is only supported for the VLA.
366 item[t] This parameter will be used in a future release to control
367 the range of applicability of the specified calibration. Currently,
368 it is ignored.
370 item[table] For pre-solved calibration, the file name of the table
371 to apply.
373 item[field] The fields to select from the specified table, using
374 MS Selection syntax (as in selectvis).
376 item[interp] The desired type of time-dependent interpolation. Use
377 {stfaf interp='nearest'} to calibrate each datum with the calibration
378 value nearest in time. Use {stfaf interp='linear'} to calibrate each
379 datum with calibration phases and amplitudes linearly interpolated
380 from neighboring (in time) values. In the case of phase, this mode
381 will assume that phase jumps greater than 180 degrees between neighboring
382 points indicate a cycle slip, and the interpolated value will follow
383 this change in cycle accordingly (i.e., the implied rate will always
384 be less than 180 degrees per sample). Use {stfaf interp='aipslin'}
385 to emulate the basic interpolation mode used in classic AIPS, i.e.,
386 linearly interpolated amplitudes, with phases derived from linear
387 interpolation of the complex calibration values. While this method
388 avoids having to track cycle slips (which is unstable for solutions
389 with very low SNR), it will yield a phase interpolation which becomes
390 increasingly non-linear as the spanned phase difference increases. The
391 non-linearity mimics the behavior of {stfaf interp='nearest'} as
392 the spanned phase difference approaches 180 degrees (the phase of the
393 interpolated complex calibration value initially changes very slowly,
394 then rapidly jumps to the second value at the midpoint of the interval).
395 If the uncalibrated phase is changing this rapidly, a 'nearest' interpolation
396 is not desirable. Usually, {stfaf interp='linear'} is the best choice.
397 The {stfaf interp} parameter is applicable to any calibration type,
398 as long as there are sufficient solutions available to perform the
399 interpolation. Note that calibration solutions which have been
400 determined for only one timestamp will default to 'nearest'. More
401 interpolation options (e.g., 'cubic') will be added in the future.
403 item[select] Used to specify general selection of a subset of
404 calibration measurements from the table to be applied to the
405 visibility data. Arbitrary cross-calibration is possible by combining
406 this function with the {stfaf setdata} function. The string
407 specified must be a valid htmladdnormallink{TaQL}{../../notes/199/199.html}
408 expression.
410 item[spwmap] This parameter is used to indicate how solutions
411 derived from different spectral windows should be applied to other
412 spectral windows. Nominally, data in each spectral window will be
413 corrected by solutions derived from the same spectral window. This is
414 the default behavior of {stfaf spwmap}, i.e., if {stfaf spwmap} is
415 not specified, calibrater will insist that data be corrected by
416 solutions from the same spw. Otherwise, {stfaf spwmap} takes a
417 vector of integers indicating which spectral window {em solutions} to
418 apply to which spectral window {em data}, such that {tt spwmap[j]=i}
419 causes solutions derived from the i-th spectral window to be used to
420 correct the j-th spectral window. For example, if (say) bandpass
421 solutions are available for spws 0 & 2, and it is desired that these
422 be applied to spws 1 & 3 (as well as 0 & 2), respectively, use
423 {stfaf spwmap=[0,0,2,2]}. Even if some spws do not require an
424 explicit {stfaf spwmap} setting, yet one or more does, it is safest
425 to specify it explicitly for all, e.g., {stfaf spwmap=[0,1,3,3]}
426 indicates that spw 2 will be corrected with solutions from spw 3, and
427 the others will behave nominally. Note that if no solutions exist
428 for any of the spws specified in {stfaf spwmap}, an error message
429 will result.
431 item[calwt] If set True, the data weights will be calibrated
432 along with the data. This is usually desirable.
434 item[opacity] For {stfaf type='TOPAC'}, an elevation-dependent
435 opacity correction will be applied according to the zenith opacity value
436 supplied in the {stfaf opacity} parameter. Currently, only one zenith
437 opacity value can be supplied, and it is used for all antennas.
439 end{description}
441 Use the {stfaf state} function to review the list of calibration
442 components that have been set for application.
444 Pending improvements:
446 begin{itemize}
447 item Enable variety of interpolation modes and timescales
448 item Allow for antenna- and time-dependent opacities
449 end{itemize}
451 Input Parameters:
452 type Component type
453 t Interpolation interval (seconds)
454 table Calibration table name
455 field Select on field
456 interp Interpolation type (in time)
457 select TAQL selection string. Default is no selection.
458 calwt Calibrate weights?
459 spwmap Spectral windows to apply
460 opacity Array-wide zenith opacity per antenna (for type='TOPAC')
462 Example:
464 cb.open('ngc5921.ms')
465 cb.selectvis(field='N5921*')
466 cb.setapply (type='G', table='gcal', field='1445*')
467 cb.setapply (type='P')
468 cb.correct();
469 cb.close();
472 In this example, we apply parallactic angle corrections and a gain
473 calibration derived from a field whose name matches '1445*' in a caltable
474 called 'gcal' to data for a field matching 'N5921*'
476 --------------------------------------------------------------------------------
478 """
479 return _calibrater.calibrater_setapply(self, *args, **kwargs)
482 def setcallib(self, *args, **kwargs):
483 """
484 setcallib(self, _callib) -> bool
488 Summary:
489 Arrange to apply calibration via a Cal Library
491 Description:
495 TBD
497 Input Parameters:
498 callib A calibration library record
500 Example:
502 TBD
504 --------------------------------------------------------------------------------
506 """
507 return _calibrater.calibrater_setcallib(self, *args, **kwargs)
510 def validatecallib(self, *args, **kwargs):
511 """
512 validatecallib(self, _callib) -> bool
516 Summary:
517 Validate a Cal Library record
519 Description:
523 TBD
525 Input Parameters:
526 callib A calibration library record
528 Example:
530 TBD
532 --------------------------------------------------------------------------------
534 """
535 return _calibrater.calibrater_validatecallib(self, *args, **kwargs)
538 def setsolve(self, *args, **kwargs):
539 """
540 setsolve(self, _type, _t, _table, _append, _preavg, _phaseonly, _apmode, _refant, _refantmode, _minblperant, _solnorm, _normtype, _minsnr, _combine, _fillgaps, _cfcache, _painc, _fitorder, _fraction, _numedge, _radius, _smooth, _zerorates, _globalsolve, _niter, _corrcomb, _delaywindow, _ratewindow, _paramactive, _concatspws, _solmode, _rmsthresh) -> bool
544 Summary:
545 Arrange to solve for calibration
547 Description:
550 This function specifies the calibration component that will be solved for
551 by the {stff solve} function. Currently, only one type can
552 be solved for at one time.
554 Each calibration component represents a separate calibration matrix
555 correction included in the measurement equation. The different types
556 correspond to different instrumental and atmospheric effects.
557 Currently, the solvable calibration components are types 'G','T','B', 'D'
558 and 'DF', which are antenna-based, and, 'M' and 'MF', which are
559 baseline-based. Arrange to pre-apply any existing calibration components (of
560 types other than the solved-for one) using the {stfaf setapply}
561 function.
563 The parameters are:
565 begin{description}
566 item[type] Specify the calibration type you want to solve for, from
567 'G','T','B','D','DF','M','MF'.
569 item[t] Specify the solution interval. This can be specified as an
570 integer (units of seconds assumed) or as a string containing a value
571 and units (e.g., '30s', '45min', '2h') or 'inf' (infinite) or 'int'
572 (per data integration). A solution interval of 0 (with or without
573 units) is the same as 'int' (per integration), and negative solution
574 intervals are treated as 'inf' (infinite).
576 item[table] Specify the output calibration table name in which to
577 store the calibration solve result. Existing tables will be
578 deleted and replaced.
580 item[append] Append the solutions to an existing table.
582 item[preavg] Specify the amount of pre-average (in time) within
583 the solution interval. By default, data are averaged up to
584 the solution interval (or up to 5 minutes for 'D' solving).
586 item[phaseonly] This parameter is deprecated, use apmode.
588 item[apmode] Control generation of amplitude-only ('a'),
589 phase-only ('p'), or amplitude-and-phase ('ap', the default) solutions.
591 item[refant] Specify an antenna (using data selection syntax)
592 for referencing the solutions.
594 item[solnorm] Normalize the solutions by their mean post-solve. For
595 'B', and 'MF', this is a complex normalization per solution spectrum.
596 For other types, this is a global (per-spw) normalization of the
597 amplitudes only.
599 item[minsnr] Specify the SNR below which solution are rejected.
601 item[combine] Specify which data axes (spw, field, scan, or some
602 combination) on which the data should be combined to generate
603 a single solution. E.g., combine='spw' will force combination
604 of many spws to form a single solution (per solution interval).
605 Similarly, combine='scan' with a long solution interval
606 will force the combination of scans to yield individual solutions
607 (per field and spw). Ordinarily, solutions are always broken
608 at scans boundaries. Separate multiple combine options with
609 commas.
611 item[fillgaps] For 'B' solutions, specify the largest solution
612 channel gap (which arise due to flagged data) that will be filled
613 post-solve via interpolation. Such solution gaps remain flagged
614 by default.
616 end{description}
618 Pending improvements:
620 begin{itemize}
621 item{Change t to solint?}
622 item{Permit flexible specification of preavg (as for t)}
623 end{itemize}
625 Input Parameters:
626 type Component type
627 t Solution interval (units optional)
628 table Output calibration table name
629 append Append to existing table?
630 preavg Pre-averaging interval (in sec)
631 phaseonly Solve only for phase?
632 apmode Solve for 'AP', 'A' (amp-only) or 'P' (phase-only)
633 refant Reference antenna. Default is none.
634 refantmode Reference antenna mode
635 minblperant Minimum number of baselines per ant for solving
636 solnorm Normalize solution after solve
637 normtype Solution normalization type
638 minsnr SNR threshold for accepting solutions
639 combine Data axes on which to combine solving (scan, spw, and/or field)
640 fillgaps
641 cfcache Name of the directory to be used for convolution function disk cache. This is used when type=EP.
642 painc Parallactic Angle increment used to trigger computation of a new convolution function. This is used when type=EP. Default value implies that only one convolution function will be computed for the entire range of observation.
643 fitorder Order of the polynomial fit, used when type='A'.
644 fraction [SINGLE-DISH SPECIFIC] Edge detection parameter for otfraster/otf calibration. This is a number of edge points as a fraction of total number of points.
645 numedge [SINGLE-DISH SPECIFIC] Edge detection parameter for otfraster calibration. This is a number of edge points. The value specified here comes before fraction. Note that edge points will be detected from both side of each raster row so that number of edge points is effectively twice of the specified value in each raster row. Default (-1) is to use fraction.
646 radius [SINGLE-DISH SPECIFIC] Specifies radius of the central region of double circle gain calibration for fast scanning data. The value must be either empty or quantum string (numeric value with unit). Default ('') is to use a radius of primary beam.
647 smooth [SINGLE-DISH SPECIFIC] Whether or not applying smoothing during double circle gain calibration for fast scanning data. Default is True.
648 zerorates [FRINGE-FIT SPECIFIC] Zero delay-rates in fringe fitting solution tables.
649 globalsolve [FRINGE-FIT SPECIFIC] Use global least-squares solver to improve fringe-fitting parameter estimates
650 niter [FRINGE-FIT SPECIFIC] Maximum number of iterations for global least-squares solver
651 corrcomb [FRINGE-FIT SPECIFIC] Combine correlations (currently supported values are 'none' and 'all')
652 delaywindow [FRINGE-FIT SPECIFIC] Constrain FFT delay search to a window; a two-element list, units of nanoseconds
653 ratewindow [FRINGE-FIT SPECIFIC] Constrain FFT rate search to a window; a two-element list, units of seconds per second
654 paramactive An array of three booleans to control whether to sove for delay, fringe-rate and dispersive delay
655 concatspws A flag to control multiband FFT behaviour in fringefit task.
656 solmode Solving mode: '', 'L1'; add 'R' for iterative outlier excision.
657 rmsthresh RMS threshold sequence.
659 Example:
661 cb.open('ngc5921.ms');
662 cb.setapply (type='P');
663 cb.setsolve (type='G',t='300s', refant=3, table='gcal');
664 cb.solve();
665 cb.close();
668 In this example, analytic (non-solvable) parallactic angle corrections
669 are pre-applied before G solutions are obtained on a timescale of 300
670 seconds. The resulting solutions are phase-referenced to antenna 3,
671 and stored in a calibration table called 'gcal'.
674 cb.reset();
675 cb.setapply (type='P',t=5.0);
676 cb.setapply (type='G',table='gcal');
677 cb.setsolve (type='D',t=86400.0, preavg=60.0, refant=3, table='dcal');
678 cb.solve();
679 cb.close();
682 In this example, the solve/apply state of the calibrater tool is reset
683 and then the P and G corrections (from above) are applied before
684 solving for D solutions on a diurnal timescale. Note that the data
685 will be averaged only to 60 seconds before the solution. The resulting
686 D solutions are stored in a table called 'dcal'.
688 --------------------------------------------------------------------------------
690 """
691 return _calibrater.calibrater_setsolve(self, *args, **kwargs)
694 def setsolvegainspline(self, *args, **kwargs):
695 """
696 setsolvegainspline(self, _table, _append, _mode, _splinetime, _preavg, _npointaver, _phasewrap, _refant) -> bool
700 Summary:
701 Specialization of setsolve for cubic spline G (time-dependent gain) solving
703 Description:
707 This function is a specialization of the {stfaf setsolve} method which
708 should be used when cubic spline G solutions are desired, e.g., when
709 SNR on calibrators is very low. Currently, this solving mode treats
710 dual polarization data on a per-polarization basis. The option to
711 obtain a joint solution (a la 'T') will be provided in the future.
713 The visibility data are averaged in frequency (for multi-channel data)
714 prior to the solution.
716 This method uses many of the basic parameters as the generic
717 {stfaf setsolve}. Parameters unique to the spline solver are:
719 begin{description}
721 item[mode] For phase solutions only, use {stfaf mode='PHAS'}. For
722 amplitude solutions only, use {stfaf mode='AMP'}. If both are
723 desired, use {stfaf mode='PHASAMP'}, and both will be solved for
724 using the same spline timescale (this mode also assumes that all
725 calibrators have the correct relative flux densities). If solving for
726 phase and amplitude separately (usually in this order), it is usually
727 desirable to apply the first one when solving for the second
728 one. Spline solution so obtained will be stored in separate
729 calibration tables. In the near future, the {stfaf mode} parameter
730 will be consolidated with the generic {stfaf apmode} parameter.
732 item[splinetime] The spline timescale (time between knots) is
733 specified here. The default is 10800 seconds (3 hours). In future
734 this parameter will be consolidated with the generic {stfaf t}
735 parameter. The {stfaf preavg} parameter should be set to a value at
736 least 4X shorter than the spline time (an error will occur if there is
737 insufficient sampling within the {stfaf splinetime} timescale), and
738 consistent with the expected coherence. Consistent with these constraints,
739 use the largest possible value for {stfaf preavg} to optimize the SNR of
740 the pre-solve phase-tracking algorithm.
742 item[npointaver and phasewrap] These parameters tune the
743 phase-unwrapping algorithm when {stfaf mode $=$ 'PHAS'}. Cycle slips
744 are detected (and removed before the spline solve) when the median
745 phase a sequence of length {stfaf npointaver} (in integrations)
746 differs by more than {stfaf phasewrap} degrees from the previous
747 sequence.
749 end{description}
751 Pending improvements:
753 begin{itemize}
754 item Consolidate more parameters with the generic {stfaf setsolve}
755 item Introduce the generic combine options
756 item Improve phase-tracking algorithm
757 end{itemize}
759 Input Parameters:
760 table Output calibration table name
761 append Append to existing table?
762 mode Phase or Amplitude mode?
763 splinetime Spline timescale (sec)
764 preavg Pre-averaging interval (in sec)
765 npointaver
766 phasewrap
767 refant Reference antenna. Default is none.
769 Example:
771 cb.open('ngc5921.ms')
772 cb.selectvis(field='1445*')
773 cb.setsolvegainspline (table='gcalph',mode='PHAS',splinetime=3600.0,preavg=60.0)cb.solve()
775 cb.setsolvegainspline (table='gcalamp',mode='AMP',splinetime=10800.0);
776 cb.solve();
777 cb.close();
780 In this example, a spline solution is first found for phase on a hourly timescale, then for amplitude on a three-hour timescale.
782 --------------------------------------------------------------------------------
784 """
785 return _calibrater.calibrater_setsolvegainspline(self, *args, **kwargs)
788 def setsolvebandpoly(self, *args, **kwargs):
789 """
790 setsolvebandpoly(self, _table, _append, _t, _combine, _degamp, _degphase, _visnorm, _solnorm, _maskcenter, _maskedge, _refant) -> bool
794 Summary:
795 Specialization of setsolve for polynomial B (bandpass) solving
797 Description:
801 This function is a specialization of the {stfaf setsolve} method
802 which should be used to arrange for bandpass solving when polynomial
803 solutions for B are desired, e.g., when per-channel SNR on calibrators
804 is too low to obtain a useful sampled bandpass.
806 Prior to the solution, the visibility data are averaged in time,
807 and the solution is performed for both phase and amplitude.
809 This method uses most of the same parameters as the generic
810 {stfaf setsolve}, with a few unique additions:
812 begin{description}
814 item[degamp and degphase] The parameters permit specification
815 of the polynomial order to use in amp and phase. Specifying
816 0 (zero) yields constant solutions.
818 item[visnorm] This parameter is used to normalize the assembled
819 spectral data, in a per baseline manner. If set True, this will have
820 the effect of removing any non-frequency-dependent closure errors
821 (e.g., as caused by source structure, or introduced by the instrument)
822 from the data, and should be used with caution. The resulting
823 solutions will be effectively normalized as well. When {stfaf
824 visnorm=F} is used, closure errors in the data (as supplied to the
825 solver) may be visible in the form of offsets between the data and
826 solutions. For bandpass calibration, this is usually ok, as the {em
827 shape} of the bandpass is the most important aspect of the solution.
828 In future this parameter will be generalized and made available
829 for other solve types. (NB: Use of {stfaf solnorm=True} still
830 provides for post-solve normalization of the solutions.)
832 item[maskcenter and maskedge] These parameters control how many
833 channels are ignored on-the-fly, at the center and edges of each input
834 spectral window, respectively. To avoid edge channels, it is almost
835 always better to flag these channels directly, or select against them
836 in {stfaf setdata}. Aggressive use of maskedge (large values), will
837 yield polynomial solutions which will tend to diverge at the edges
838 (especially when the polynomial degree is also high), because maskedge
839 does not change the frequency domain of the solutions. Such solutions
840 should be used with caution in subsequent operations. (It is best to
841 avoid use of maskedge.)
842 end{description}
844 The BPOLY solution is performed for both phase and amplitude, and the
845 result will be stored in the same table. The frequency domain of the
846 solutions is limited to only the range of frequencies selected in
847 {stfaf selectvis}. When correcting data with these solutions (for
848 other solves or with {stfaf correct}), only data within this domain
849 will be corrected. Data outside (e.g., edge channels avoided in
850 {stfaf setdata} for the solve), will not be corrected. Therefore,
851 the same (or narrower) channel selection is recommended for all
852 operations using solutions produced by this function and {stfaf
853 solve()}.
855 Note that the {stfaf combine} parmaeter can be used meaningfully with
856 the BPOLY solver. When combine='spw', the data from multiple spws
857 will be combined on a common frequency axis, and a single polynomial
858 will be determined spanning them all. This is different than for
859 ordinary sampled 'B' solutions, for which combine='spw' causes the
860 bandpass to be combined on a common channel axis, effectively yielding
861 a mean bandpass for the set of spws.
863 Input Parameters:
864 table Output calibration table name
865 append Append to existing table?
866 t Solution interval (units optional)
867 combine Data axes on which to combine solving (scan, spw, and/or field)
868 degamp Polynomial degree for amplitude solution
869 degphase Polynomial degree for phase solution
870 visnorm Normalize data prior to solution
871 solnorm Normalize result?
872 maskcenter Number of channels to avoid in center of each band
873 maskedge Fraction of channels to avoid at each band edge (in %)
874 refant Reference antenna
876 Example:
878 cb.open('ngc5921.ms');
879 cb.selectvis(field='1331*')
880 cb.setsolvebandpoly(table='bpoly',degamp=5,degphase=7);
881 cb.solve();
882 cb.close();
885 In this example, amplitude (degree 5) and phase (degree 7) Chebychev
886 polynomial bandpasses are determined using the default parameters.
888 --------------------------------------------------------------------------------
890 """
891 return _calibrater.calibrater_setsolvebandpoly(self, *args, **kwargs)
894 def returndict(self):
895 """
896 returndict(self) -> record *
900 Summary:
901 Return a dictionary describing the current calibrater state
903 Description:
907 Return a dictionary containing information about the current calibrater tool state.
908 This dictionary contains the following keys: 'antennas', 'apply tables', 'field', 'intents', 'observation', 'scan', 'solve table', 'spw'.
910 Each of these keys will show which values for each of these parameters are selected. By default all of the MS is selected when opened by the calibrater tool.
912 The values of each of these keys is an array of either strings or integers.
915 Example:
917 cb.open('gaincaltest2.ms')
918 cb.selectvis(field='1')
919 cb.returndict()
921 This would return a dictionary that looks like this:
923 {'antennas': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
924 'apply tables': array([], dtype='U16'),
925 'field': array([1]),
926 'intents': array(['CALIBRATE_AMPLI#ON_SOURCE', 'CALIBRATE_DELAY#ON_SOURCE',
927 'CALIBRATE_PHASE#ON_SOURCE', 'CALIBRATE_WVR#ON_SOURCE'],
928 dtype='U26'),
929 'observation': array([0]),
930 'scan': array([ 3, 5, 8, 10, 12, 15, 17, 20, 22, 24]),
931 'solve table': array([], dtype='U16'),
932 'spw': array([0, 1, 2, 3])}
934 --------------------------------------------------------------------------------
936 """
937 return _calibrater.calibrater_returndict(self)
940 def state(self):
941 """
942 state(self) -> bool
946 Summary:
947 Request the apply/solve state of the calibrater tool
949 Description:
953 Request the apply/solve state of the calibrater tool. A listing of
954 all calibration components that have been set for application or
955 solving is written to the logger.
957 Example:
959 cb.open('ngc5921.ms');
960 cb.setapply ('P', 5.0);
961 cb.setsolve ('G', 300.0, F, 3, 'gcal_1', T);
962 cb.state();
964 --------------------------------------------------------------------------------
966 """
967 return _calibrater.calibrater_state(self)
970 def reset(self, *args, **kwargs):
971 """
972 reset(self, _apply, _solve) -> bool
976 Summary:
977 Reset the selected apply and/or solve components
979 Description:
983 Resets the apply and/or solve components previously set by setapply and
984 setsolve.
986 Input Parameters:
987 apply If true, unset all apply settings
988 solve If true, unset all solve settings
990 Example:
992 cb.open('ngc5921.ms')
993 cb.setapply ('P', 5.0)
994 cb.setsolve ('G', 300.0, F, 3, 'gcal_1', T)
995 cb.state()
996 cb.reset(apply=T,solve=F);
997 cb.state()
998 cb.reset()
1000 --------------------------------------------------------------------------------
1002 """
1003 return _calibrater.calibrater_reset(self, *args, **kwargs)
1006 def initcalset(self, *args, **kwargs):
1007 """
1008 initcalset(self, _calset) -> bool
1012 Summary:
1013 Re-initialize the calibration scratch columns.
1015 Description:
1019 This function re-initializes the calibration scratch columns:
1020 MODEL_DATA to unity (in total intensity, and unpolarized), and
1021 CORRECTED_DATA to (observed) DATA.
1022 Optionally if calset is set to 1 any model saved in the MS header to for calibration
1023 purposes is deleted
1025 Input Parameters:
1026 calset if it set to 1 the model saved in the header is removed
1028 Example:
1030 cb.open('ngc5921.ms');
1031 cb.initcalset();
1032 cb.solve();
1034 --------------------------------------------------------------------------------
1036 """
1037 return _calibrater.calibrater_initcalset(self, *args, **kwargs)
1040 def delmod(self, *args, **kwargs):
1041 """
1042 delmod(self, _otf, _field, _spw, _scr) -> bool
1046 Summary:
1047 Delete model data representations in the MS.
1049 Description:
1053 This method can be used to delete the model visibility
1054 data representations in the MS. The 'otf' representation is
1055 the new (as of v3.4) 'scratch-less' model data, stored as
1056 keywords in the MS header containing model data formation
1057 instructions. It is generated by the im tool (setjy, ft, and clean
1058 methods; usescratch=F in im.open), and if present, overrides the
1059 old-fashioned MODEL_DATA column (if present). If a user
1060 wishes to use the MODEL_DATA column _after_ having operated
1061 with the 'otf' representation, this method can be used
1062 to delete the 'otf' represenatation to make the MODEL_DATA
1063 column visible. (Create the MODEL_DATA column by using
1064 usescratch=T in the im tool, or by running the cb.open
1065 with addmodel=T.)
1067 If otf=T, the user may selectively remove only a selection of fields model from the MS by specifying the field parameter. Similarly if the field parameter is specified, selected spws model for those fields may be deleted by specifying the spw.
1070 For convenience, this method also provides a means for
1071 deleting the MODEL_DATA column by setting scr=T.
1073 Input Parameters:
1074 otf If T, delete the otf model data keywords
1075 field Select on field
1076 spw Select on spw only if field is defined
1077 scr If T, delete the MODEL_DATA column
1079 Example:
1081 cb.open('ngc5921.ms');
1082 cb.delmod(otf=T,scr=F); # delete only the otf model for all fields
1083 cb.solve();
1085 cb.open('n4826.ms')
1086 cb.delmod(otf=T, field='1')
1087 #delete otf model of field 1 only, all other fields model are untouched
1088 #if present
1089 cb.open('n4826.ms')
1090 cb.delmod(otf=T, field='1', spw='2')
1091 #delete otf model of field 1 and spectralwindow 2 only.
1093 ####NOTE doing:
1094 cb.delmod(otf=T, field='', spw='2')
1096 #will delete all otf models and spw will be ignored
1098 --------------------------------------------------------------------------------
1100 """
1101 return _calibrater.calibrater_delmod(self, *args, **kwargs)
1104 def solve(self):
1105 """
1106 solve(self) -> bool
1110 Summary:
1111 Solve for the selected calibration components
1113 Description:
1116 Execution of this function initiates a solve for the calibration component
1117 specified in a previous {stfaf setsolve} execution. Existing calibration
1118 components (as specified in one or more {stfaf setapply} executions) will
1119 be appropriately applied to the observed and model data according to their
1120 position in the Measurement Equation, and their commutation properties.
1122 Example:
1124 cb.open('ngc5921.ms');
1125 cb.setapply ('P', t=10)
1126 cb.setsolve ('G', 300.0, F, 3, 'gcal_1', T);
1127 cb.solve();
1128 cb.close();
1130 --------------------------------------------------------------------------------
1132 """
1133 return _calibrater.calibrater_solve(self)
1136 def correct(self, *args, **kwargs):
1137 """
1138 correct(self, _applymode) -> bool
1142 Summary:
1143 Apply calibration information
1145 Description:
1149 This function applies the calibration components specified via one or
1150 more invocations of the {stff setapply} function to the observed
1151 visibility data and writes the result to the CORRECTED_DATA column
1152 of the Measurement Set.
1154 Input Parameters:
1155 applymode Correction cal/flag mode: ''='calflag','cal','flag','trial'
1157 Example:
1159 cb.open('ngc5921.ms');
1160 cb.selectvis(field='1445*')
1161 cb.setapply ('G', 10.0, 'gcal_1')
1162 cb.correct();
1163 cb.close();
1165 --------------------------------------------------------------------------------
1167 """
1168 return _calibrater.calibrater_correct(self, *args, **kwargs)
1171 def corrupt(self):
1172 """
1173 corrupt(self) -> bool
1177 Summary:
1178 Corrupt model with calibration tables
1180 Description:
1184 This function applies the calibration components specified via one or
1185 more invocations of the {stff setapply} function to the model
1186 visibility data and (over-)writes the result to the MODEL_DATA column of the
1187 Measurement Set.
1189 Example:
1191 cb.open('ngc5921.ms')
1192 cb.selectvis(field='1445*')
1193 cb.setapply ('G', 10.0, 'gcal_1')
1194 cb.corrupt()
1195 cb.close()
1197 --------------------------------------------------------------------------------
1199 """
1200 return _calibrater.calibrater_corrupt(self)
1203 def initweights(self, *args, **kwargs):
1204 """
1205 initweights(self, _wtmode, _dowtsp, _tsystable, _gainfield, _interp, _spwmap) -> bool
1209 Summary:
1210 Initialize MS weight info in various ways.
1212 Description:
1216 This function initializes the MS weight info in various ways.
1218 If wtmode='ones', SIGMA and WEIGHT will be initialized with 1.0,
1219 globally.
1221 If wtmode='nyq' (the default), SIGMA and WEIGHT will be initialized
1222 according to bandwidth and integration time. This is the
1223 theoretically correct mode for raw normalized visibilities.
1225 If wtmode='sigma', WEIGHT will be initialized according to the
1226 existing SIGMA column.
1228 If mode='weight', WEIGHT_SPECTRUM will be initialized according to the
1229 existing WEIGHT column; dowtspec=T must be specified in this case.
1231 For the above wtmodes, if dowtspec=T (or if the WEIGHT_SPECTRUM column
1232 already exists), the WEIGHT_SPECTRUM column will be initialized
1233 (uniformly in channel), in a manner consistent with the WEIGHT column.
1234 If the WEIGHT_SPECTRUM column does not exist, dowtsp=T will force its
1235 creation.
1237 The follow modes should be used with extreme care: If
1238 wtmode='delwtsp', the WEIGHT_SPECTRUM column will be deleted (if it
1239 exists). If wtmode='delsigsp', the SIGMA_SPECTRUM column will be
1240 deleted (if it exists). Note that creation of SIGMA_SPECTRUM is not
1241 supported via this method.
1243 Note that this method does not support any prior selection.
1244 Intialization of the weight information must currently be done
1245 globally or not at all. This is to maintain consistency.
1247 Input Parameters:
1248 wtmode Initialization mode
1249 dowtsp Initialize WEIGHT_SPECTRUM column
1250 tsystable Tsys calibration table to apply on the fly
1251 gainfield Select a subset of calibrators from Tsys caltable
1252 interp Interp type in time[,freq]. default==linear,linear
1253 spwmap Spectral windows combinations to form for gaintables(s)
1255 Example:
1257 cb.open('ngc5921.ms')
1258 cb.initweights()
1259 cb.close()
1261 --------------------------------------------------------------------------------
1263 """
1264 return _calibrater.calibrater_initweights(self, *args, **kwargs)
1267 def fluxscale(self, *args, **kwargs):
1268 """
1269 fluxscale(self, _tablein, _reference, _tableout, _transfer, _listfile, _append, _refspwmap, _gainthreshold, _antenna, _timerange, _scan, _incremental, _fitorder, _display) -> record *
1273 Summary:
1274 Bootstrap the flux density scale from standard calibrators
1276 Description:
1280 This function is used to bootstrap the amplitude scale the
1281 calibration solutions according to specified reference calibrator(s)
1282 of known flux density. This is necessary when the flux densities
1283 of some of your calibrators were unknown (and thus were assumed
1284 to be 1 Jy) during G solving.
1286 The bootstrapping is achieved by comparing the median gain norm of the
1287 calibration solutions derived for the calibrators specified in {stfaf
1288 reference} (one or more sources with known flux densities at the time
1289 of G solving) with that of the calibrators specified in {stfaf
1290 transfer}, and enforcing the assumption that the antenna gains are
1291 constant, on average. The gain solutions for the transfer sources are
1292 then re-scaled accordingly. The {stfaf reference} and {stfaf transfer}
1293 parameters may be specified using the general field selection syntax
1294 (as in {stfaf field} in {stfaf selectvis}).
1296 If no {tt transfer} fields are specified, then the solutions for
1297 all non-reference fields in {tt tablein} will be re-scaled.
1299 If no {tt tableout} is specified the input table will be overwritten
1300 with the scaled solutions. Note that the resulting table will only
1301 contain solutions for those fields implicit in the {tt reference} and
1302 {tt transfer} specifications. Use {tt append=T} to append the scaled
1303 solutions to an existing table.
1305 Use the {stfaf refspwmap} parameter to indicate how data for
1306 different spectral windows should be matched in calculating the flux
1307 density scale factor for {stfaf transfer} fields. The default
1308 behavior for {tt refspwmap} is to insist on precisely matching
1309 spectral windows for {tt reference} and {tt transfer} fields. When
1310 specified, the {stfaf refspwmap} parameter takes a vector of integers
1311 indicating which spectral window solutions to use as the reference for
1312 others, such that {tt refspwmap[j]=i} causes solutions (from reference
1313 fields) observed in the i-th spectral window to be used to reference
1314 solutions (from transfer fields) observed in the j-th spectral window.
1315 For example, for the case of a total of 4 spectral windows: if the
1316 {tt reference} fields were observed only in spw=2 & 4, and the {tt
1317 transfer} fields were observed variously in all 4 spws, specify {tt
1318 refspwmap=[2,2,4,4]}. This will ensure that {tt transfer} fields
1319 observed in spws 1,2,3,4 will be referenced to {tt reference} field
1320 data from spws 2,2,4,4, respectively. Note that if the {tt transfer}
1321 fields were observed only in spws 1 & 3, the same specification would
1322 work, but {tt refspwmap=[2,2,4]} would suffice. In this case,
1323 nothing need be specified for the 4th spw (there are no transfer
1324 fields there), and specifying 2 for the 2nd spw is actually
1325 inconsequential (though required so that the specification of 4 for spw 3
1326 is properly interpretted).
1328 The gain values used in the flux scaling determination skewed by
1329 outliers. The parameters, {tt gainthreshold} and {tt antenna} can be used
1330 to limit the input gain solutions to be included in the flux scale determination.
1331 Use the {tt gainthreshold} is a threshold in % from the median values of the
1332 gain solutions to be used. Use the {tt antenna} to select or de-selesect (using the
1333 MSSelection syntax) antenna(s). Futher refinements on the selection based on
1334 timerange and scan are possible.
1336 The derived flux densities for the transfer fields will be reported in
1337 the logger, and returned to the Python dictionary specified in {tt
1338 fluxd}. This will be an 2D array of shape [number-of-spectral-windows
1339 X number-of-fields]. When mulitple spectral windows are involved the spectral
1340 index will also be reported by fitting the determined flux densities across
1341 the freuquencies. The order of a polynomcial to be fitted can be specified with
1342 {tt fitorder}.
1344 Note that elevation-dependent gain effects may render the basic
1345 assumption used here invalid, and so should be corrected for prior to
1346 solving for G, using types 'TOPAC' or 'GAINCURVE' in {tt setapply}.
1348 Note that the visibility data itself is not used directly by this
1349 function.
1351 Pending improvements:
1353 begin{itemize}
1354 item Allow antenna and uv-distance selection to improve results for
1355 resolved calibrators
1356 item Set the visibility model according to the flux density results
1357 item An option to use the data to derive the relative flux densities
1358 end{itemize}
1360 Input Parameters:
1361 tablein Input calibration table name
1362 reference Reference calibrator field names (comma-separated)
1363 tableout Output calibration table name. Default is input calibration table name.
1364 transfer Transfer source field names (comma-separated). Default is all other fields.
1365 listfile Name of listfile that contains the fit information. Default is '' (no file).
1366 append Append to existing table?
1367 refspwmap List of alternate spw for referencing
1368 gainthreshold Threshold of gain amplitudes with respect to the median value to be used in flux scale calculation. Default: -1.0 (no threshold)
1369 antenna antenna selection/de-selection in flux scale calculation. Default: ''(include all antennas)
1370 timerange timerage sub-selection with antenna selection in flux scale calculation. Default: ''(include all)
1371 scan scan sub-selection with antenna selection in flux scale calculation. Default: ''(include all)
1372 incremental create a incremental caltable
1373 fitorder order for spectral fitting for multiple spws
1374 display display statistics of the flux ratios
1376 Example:
1378 cb.open('ngc5921.ms')
1379 cb.selectvis(field='1331*,1445*')
1380 cb.setsolve(type='G',table='gcal',t='inf')
1381 cb.solve()
1382 cb.fluxscale (tablein='gcal', tableout='flxcal',
1383 reference='1331*', transfer='1445*');
1384 cb.close();
1387 This example generates a calibration table containing {tt G}
1388 solutuions ('gcal') and then writes a re-scaled version, using
1389 1335+305 as the reference calibrator, to derive properly scaled
1390 amplitude calibration for the transfer source, 1445+099. We have
1391 assumed that 1331+305 has already had its MODEL_DATA set to
1392 the correct flux density.
1394 --------------------------------------------------------------------------------
1396 """
1397 return _calibrater.calibrater_fluxscale(self, *args, **kwargs)
1400 def accumulate(self, *args, **kwargs):
1401 """
1402 accumulate(self, _tablein, _incrtable, _tableout, _field, _calfield, _interp, _t, _spwmap) -> bool
1406 Summary:
1407 Accumulate incremental calibration solutions into a cumulative calibration table
1409 Description:
1413 This function enables cumulative calibration using {tt calibrater}.
1414 It is the analog of the task ``CLCAL'' in classic AIPS.
1416 The {tt accumulate} function is useful when:
1418 begin{itemize}
1419 item a calibration solution of a particular type already exists,
1420 item an incremental calibration solution {em of the same type} is desired
1421 (an incremental solution in this context means derived independently
1422 from, or determined with respect to, the first)
1423 item the first calibration cannot be implicitly recovered in the course
1424 of obtaining the incremental solution
1425 end{itemize}
1427 For example, a phase-only ``G'' self-calibration on a target source
1428 may be desired to tweak the full amplitude and phase ``G'' calibration
1429 already obtained from a calibrator. The initial calibration (from the
1430 calibrator) contains amplitude information, and so must be carried
1431 forward, yet the phase-only solution itself cannot (by definition)
1432 recover this information, as a full amplitude and phase
1433 self-calibration would. In this case, the initial solution must be
1434 applied while solving for the phase-only solution, then the two
1435 solutions combined to form a {em cumulative} calibration embodying
1436 the net effect of both. In terms of the Measaurement Equation, the net
1437 calibration is the {em product} of the initial and incremental
1438 solutions.
1440 The analog of {tt accumulate} in classic AIPS is the use of CLCAL to
1441 combine a series of (incremental) SN calibration tables to form
1442 successive (cumulative) CL calibration tables.
1444 Cumulative calibration tables also provide a means of generating
1445 carefully interpolated calibration, on variable user-defined
1446 timescales, that can be examined prior to application to the data with
1447 {tt setapply} and {tt correct}. The solutions for different fields
1448 and/or spectral windows can be interpolated in different ways, with
1449 all solutions stored in the same table.
1451 The only difference between incremental and cumulative calibration
1452 tables is that incremental tables are generated directly from the data
1453 via {tt solve} or (in the near future) from other ancilliary data
1454 (e.g. weather information), and cumulative tables are generated from
1455 other cumulative and incremental tables via {tt accumulate}. In all
1456 other respects (internal format, application to data via {tt
1457 setapply} and {tt correct}, plotting with {tt plotcal}, etc.), they
1458 are the same, and therefore interchangable. Thus, {tt accumulate} and
1459 cumulative calibration tables need only be used when circumstances
1460 require it.
1462 The {tt accumulate} function represents a generalization on the
1463 classic AIPS CLCAL model of cumulative calibration in that its
1464 application is not limited to accumulation of ``G'' solutions (SN/CL
1465 tables classic AIPS are the analog of ``G'' (and, implicitly, ``T'')
1466 in {tt aips++}). In principle, any basic calibration type can be
1467 accumulated (onto itself), as long as the result of the accumulation
1468 (matrix product) is of the same type. This is true of all the basic
1469 types, except ``D''. Accumulation is currently supported for ``B'',
1470 ``G'', and ``T'', and, in future, ``F'' (ionospheric Faraday
1471 rotation), ``J'' (generic full-polarization calibration),
1472 fringe-fitting, and perhaps others. Accumulation of certain
1473 specialized types (e.g., ``GSPLINE'', ``TOPAC'', etc.) onto the basic
1474 types will be supported in the near future. The treatment of various
1475 calibration from ancilliary data (e.g., system temperatures, weather
1476 data, WVR, etc.), as they become available, will also make use of {tt
1477 accumulate} to achieve the net calibration.
1479 Note that accumulation only makes sense if treatment of a uniquely
1480 incremental solution is required (as described above), or if a careful
1481 interpolation or sampling of a solution is desired. In all other
1482 cases, re-solving for the type in question will suffice to form
1483 the net calibration of that type. For example, the product of
1484 an existing ``G'' solution and an amplitude and phase ``G'' self-cal
1485 (solved with the existing solution applied), is equivalent to full
1486 amplitude and phase ``G'' selfcal (with no prior solution applied),
1487 as long as the timescale of this solution is at least as short as
1488 that of the existing solution.
1490 Use of {tt accumulate} is straightforward:
1492 The {tt tablein} parameter is used to specify the existing cumulative
1493 calibration table to which an incremental table is to be applied.
1494 Initially, no such table exists, and {tt accumulate} will generate
1495 one from scratch (on-the-fly), using the timescale (in seconds)
1496 specified by the parameter {tt t}. These nominal solutions will
1497 be unit-amplitude, zero-phase (i.e., unit matrix) calibration,
1498 ready to be adjusted by accumulation. When {tt t} is negative (the
1499 default), the table name specified in {tt tablein} must exist and
1500 will be used.
1502 The {tt incrtable} parameter is used to specify the incremental table
1503 that should be applied to {tt tablein}. The calibration type of
1504 {tt incrtable} sets the type assumed in the operation, so {tt
1505 tablein} must be of the same type. If it is not, {tt accumulate}
1506 will exit with an error message. (Certain combinations of types
1507 and subtypes will be supported by accumulate in the future.)
1509 The {tt tableout} parameter is used to specify the name of the output
1510 table to write. If un-specified (or ``''), then {tt tablein} will be
1511 overwritten. Use this feature with care, since an error here will
1512 require building up the cumulative table from the most recent distinct
1513 version (if any).
1515 The {tt field} parameter specifies those field names (standard
1516 selection syntax) in {tt tablein} to which the incremental solution
1517 should be applied. The solutions for other fields will be passed to
1518 {tt tableout} unaltered. If the cumulative table was created from
1519 scratch in this run of {tt accumulate}, then these solutions will be
1520 unit-amplitude, zero-phase, as described above.
1522 The {tt calfield} parameter is used to specify the fields (standard
1523 selection syntax) to select from {tt incrtable} to use when applying
1524 to {tt tablein}. Together, use of {tt field} and {tt calfield}
1525 permit completely flexible combinations of calibration accumulation
1526 with respect to fields. Multiple runs of {tt accumulate} can be used
1527 to generate a single table with many combinations. In future, a
1528 ``self'' mode will be enabled that will simplify the accumulation of
1529 field-specific solutions.
1531 The {tt interp} parameter is used to specify the interpolation type
1532 to use on the incremental solutions, as in {tt setapply}. The
1533 currently available interpolation types are ``nearest'', ``linear'',
1534 and ``aipslin''. See the {tt setapply} URM documentation for more
1535 details.
1537 The {tt spwmap} parameter enables accumulating solutions from
1538 differing spectral windows. See {tt setapply} for details
1539 on how spwmap works.
1541 Pending improvements:
1543 begin{itemize}
1544 item Implement a ``self'' mode (independent of interpolation type),
1545 to simplify or eliminate use of the {tt field} and {tt calfield}
1546 parameters in some contexts (e.g., self-cal)
1547 item More interpolation modes, e.g., ``cubic'', and interpolation
1548 timescale (timerange to permit interpolation)
1549 item Handle propogation (or not) of bad/flagged solutions
1550 item Support of specialized types (e.g., TOPAC) onto the basic
1551 types
1552 item Smoothing (probably a separate function)
1553 end{itemize}
1555 Input Parameters:
1556 tablein Input cumulative calibration table name
1557 incrtable Input incremental calibration table name
1558 tableout Output cumulative calibration table name. Default is input table name.
1559 field List of fields (names) to update in input cumulative table. Default is all.
1560 calfield List of fields (names) in incremental table to use. Default is use all.
1561 interp Interpolation mode to use on incremental solutions
1562 t Cumulative table timescale when creating from scratch
1563 spwmap Spectral windows to apply
1565 Example:
1567 cb.open('ap366.sim');
1569 # obtain G solutions from calibrator
1570 cb.selectvis(msselect='FIELD_ID IN [9,11]');
1571 cb.setsolve(type='G',table='cal.G0',t=300);
1572 cb.solve()
1574 # obtain proper flux density scale
1575 cb.fluxscale (tablein='cal.G0', tableout='cal.G1',
1576 reference='1328+307', transfer='0917+624');
1578 # generate cumulative table for target source on 20s timescale
1579 cb.accumulate(tablein='',incrtable='cal.G1',tableout='cal.cG0',
1580 field='0957+561',calfield='0917+624',
1581 interp='linear',t=20);
1583 # apply this calibration to target
1584 cb.selectvis(msselect='FIELD_ID==10');
1585 cb.setapply(type='G',table='cal.cG0',interp='linear')
1586 cb.correct();
1588 # (image target with imager tool)
1590 # phase-selfcal target on 60s timescale
1591 cb.selectvis(msselect='FIELD_ID==10');
1592 cb.setapply(type='G',table='cal.cG0',interp='linear')
1593 cb.setsolve(type='G',table='cal.G2',t=60,phaseonly=T);
1594 cb.solve();
1596 # accumulate new solution onto existing one
1597 cb.accumulate(tablein='cal.cG0',incrtable='cal.G2',tableout='cal.cG1',
1598 field='0957+561',calfield='0957+561',
1599 interp='linear');
1601 # apply new cumulative solution to data
1602 cb.setapply(type='G',table='cal.cG1',interp='linear')
1603 cb.correct();
1605 # (another round of imaging, etc.)
1607 cb.close();
1609 --------------------------------------------------------------------------------
1611 """
1612 return _calibrater.calibrater_accumulate(self, *args, **kwargs)
1615 def activityrec(self):
1616 """
1617 activityrec(self) -> record *
1621 Summary:
1622 Returns a record containing properties of recent activity
1624 Description:
1628 This funtion enables returning generic information about recent activity.
1631 Pending improvements:
1633 begin{itemize}
1634 item ??
1635 end{itemize}
1637 Example:
1639 TBD
1641 --------------------------------------------------------------------------------
1643 """
1644 return _calibrater.calibrater_activityrec(self)
1647 def specifycal(self, *args, **kwargs):
1648 """
1649 specifycal(self, _caltable, _time, _spw, _antenna, _pol, _caltype, _parameter, _infile, _uniform) -> bool
1653 Summary:
1654 Externally specify calibration of various types
1656 Description:
1660 This function enables specifying calibration parameters externally.
1662 Input Parameters:
1663 caltable The calibration table name
1664 time Calibration timestamp
1665 spw Calibration spw(s)
1666 antenna Calibration antenna(s)
1667 pol Calibration polarization
1668 caltype Calibration timestamp
1669 parameter Calibration parameters
1670 infile Ancillary input file
1671 uniform Assume uniform calibration values across the array
1673 Example:
1675 cb.open('ap366.sim');
1677 (TBD)
1679 cb.close();
1681 --------------------------------------------------------------------------------
1683 """
1684 return _calibrater.calibrater_specifycal(self, *args, **kwargs)
1687 def smooth(self, *args, **kwargs):
1688 """
1689 smooth(self, _tablein, _tableout, _field, _smoothtype, _smoothtime, _ratesmooth) -> bool
1693 Summary:
1694 Produce a smoothed calibration table
1696 Description:
1700 This function provides for time-dependent smoothing of sampled
1701 calibration solutions. Currently supported types are 'G', 'B', and 'T'.
1702 (Smoothing on the frequency axis for 'B' will be supported in the near
1703 future.)
1705 Two (sliding) smoothing types are currenlty supported: 'median' or
1706 'mean', one of these options should be specified in {stfaf
1707 smoothtype}. The full width (in seconds) of the smoothing filter
1708 should be specified in {stfaf smoothtime}. Amplitude and
1709 (ambiguity-corrected) phase are smoothed separately.
1711 Use {stfaf field} to limit the smoothing operation to a subset of the
1712 fields (standard selection syntax) found in the calibration table
1713 (other fields will pass to the output table unsmoothed). If {stfaf
1714 field} is left blank, all fields in the table will be smoothed.
1716 The smoothing is always done independently for each field, but
1717 scan boundaries are not observed. Thus, if the {stfaf smoothtime}
1718 is large enough, smoothing may occur over many boundaries.
1720 Flagged solutions in the input table will not participate in the
1721 smoothing calculation, but will be replaced with smoothed values
1722 if the smoothing window covers one or more unflagged solutions when
1723 centered on the flagged point.
1725 Pending improvements:
1727 begin{itemize}
1728 item Add other smoothtypes?
1729 item Add spw and other selection on input table
1730 item Add A/P toggle
1731 end{itemize}
1733 Input Parameters:
1734 tablein Input calibration table
1735 tableout Output calibration table
1736 field Limit smoothing to these fields (default is all fields)
1737 smoothtype The smoothing type: 'mean' or 'median'
1738 smoothtime Smoothing filter time constant (sec)
1739 ratesmooth Use rate aware smoothing with fringfit data
1741 Example:
1743 cb.open('ngc5921.ms');
1744 cb.smooth(tablein='in.gcal',tableout='out.gcal',
1745 smoothtype='median',smoothtime=60);
1746 cb.close();
1749 In this example, 'G' solutions for all fields in the table 'in.gcal' are
1750 smoothed using a median filter with a full-width of 60 seconds,
1751 and the result written to 'out.gcal'.
1753 --------------------------------------------------------------------------------
1755 """
1756 return _calibrater.calibrater_smooth(self, *args, **kwargs)
1759 def rerefant(self, *args, **kwargs):
1760 """
1761 rerefant(self, _tablein, _tableout, _refantmode, _refant) -> bool
1765 Summary:
1766 Apply a new reference antenna
1768 Description:
1772 TBD
1774 Pending improvements:
1776 begin{itemize}
1777 item TBD
1778 end{itemize}
1780 Input Parameters:
1781 tablein Input calibration table
1782 tableout Output calibration table
1783 refantmode The refant application mode
1784 refant Reference antenna. Default is none.
1786 Example:
1788 cb.open('ngc5921.ms');
1789 cb.rerefant(tablein='in.gcal',tableout='out.gcal',
1790 refantmode='median',refant='4')
1791 cb.close();
1793 --------------------------------------------------------------------------------
1795 """
1796 return _calibrater.calibrater_rerefant(self, *args, **kwargs)
1799 def listcal(self, *args, **kwargs):
1800 """
1801 listcal(self, _caltable, _field, _antenna, _spw, _listfile, _pagerows) -> bool
1805 Summary:
1806 List the contents of a calibration table
1808 Description:
1812 calibrater.listcal() lists antenna gain solutions in tabular
1813 form. The table is organized as follows. Solutions are output by
1814 begin{enumerate}
1815 item Spectral window,
1816 item Antenna,
1817 item Time,
1818 item Channel,
1819 item and Polarization.
1820 end{enumerate}
1821 The inner-most loop is over polarization.
1822 A ``Spw Header'' row is printed each time the spectral window changes.
1823 In addition to listing the spectral window ID (SpwID), the Spw Header
1824 also lists the date of observation (Date), the calibration table name (CalTable), and the measurement
1825 set name (MS name). A lower-level ``antenna header'' is printed each time the antenna
1826 names change or every `pagerows' of output, whichever comes first.
1827 The antenna header column are described here:
1829 begin{tabular}{ll}
1830 hline hline
1831 Column Name & Description
1832 hline
1833 Ant & Antenna name
1834 Time & Visibility timestamp corresponding to gain solution
1835 Field & Field name
1836 Chn & Channel number
1837 Amp & Complex solution amplitude
1838 Phs & Complex solution phase
1839 F & Flag
1840 hline hline
1841 end{tabular}
1843 Elements of the ``F'' column contain an `F' when the datum is flagged,
1844 and ` ' (whitespace) when the datum is not flagged.
1846 Presently, the polarization mode names (for example: R, L)
1847 are not given, but the ordering of the polrization modes (left-to-right) is
1848 equivalent to the order output by task listobs (see ``Feeds'' in listobs output).
1850 Input Parameters:
1851 caltable Calibration table to list
1852 field Field names or indices to list: ''==>all
1853 antenna Antenna/Baseline to list: ''==>all
1854 spw Spectral windows and channels: ''==>all, spw='10:8~20'
1855 listfile Send output to file: ''==>send to terminal)
1856 pagerows Rows per page
1858 Example:
1860 Input:
1862 The following example imports a UVFITS file, performs a bandpass calibration,
1863 and displays a subset of the resulting calibration table.
1865 pathname=os.environ.get('CASAPATH').split()[0] # Get path to CASA home dir
1866 fitsdata=pathname+'/data/demo/NGC5921.fits' # Select uv-data (FITS) file
1867 msdata='NGC5921.ms' # MS name; write to current directory
1868 importuvfits(fitsfile=fitsdata, vis=msdata) # import FITS data to MS
1869 setjy(vis=msdata) # Create model data for flux calibrator
1870 caldata=msdata+'.bcal' # Calibration table name
1871 bandpass(vis=msdata, caltable=caldata) # Bandpass calibration
1872 cb.open(msdata) # Open MS in cb
1873 cb.listcal(caltable=caldata, field='N5921_2, 0, 1', antenna='1~5;10~13;20~22', spw='0:4~6', pagerows=0) # List a subset of calibration factors
1875 Output:
1877 SpwID = 0, Date = 1995/04/13, CalTable = NGC5921.ms.bcal (B Jones), MS name = /users/jcrossle/NRAO/casa/NGC5921.ms
1878 -------------------------------------------------------------------------------------------------------------------------------------------------------
1879 | Ant = 1 | Ant = 2 | Ant = 3 | Ant = 4 |
1880 Time Field Chn| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F|
1881 ----------|---------------|---|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|
1882 09:21:46.0 1331+30500002_0 4|0.294 5.3 0.264 3.5 0.296 105.9 0.287 -111.9 0.276 -66.0 0.264 -24.5 0.269 165.8 0.281 -108.6
1883 09:21:46.0 1331+30500002_0 5|0.303 5.3 0.279 0.6 0.305 107.0 0.298 -111.6 0.283 -64.2 0.274 -23.3 0.280 166.8 0.291 -108.9
1884 09:21:46.0 1331+30500002_0 6|0.307 5.6 0.287 -1.6 0.309 107.5 0.303 -111.5 0.287 -63.2 0.280 -22.6 0.284 167.8 0.296 -108.8
1885 10:05:27.9 1445+09900002_0 4|0.467 7.6 0.419 2.7 0.473 107.7 0.455 -112.3 0.437 -63.5 0.413 -24.8 0.427 168.2 0.446 -108.8
1886 10:05:27.9 1445+09900002_0 5|0.472 7.3 0.440 0.0 0.486 109.1 0.471 -111.8 0.451 -62.6 0.436 -23.1 0.435 169.4 0.453 -108.5
1887 10:05:27.9 1445+09900002_0 6|0.486 8.4 0.453 -2.4 0.482 110.0 0.478 -111.4 0.452 -60.7 0.443 -23.1 0.446 169.6 0.468 -108.6
1888 10:09:05.3 N5921_2 4|0.082 50.0 0.074 34.7 0.097 -74.5 0.083 54.4 0.070 131.3 0.080 150.7 0.085 81.0 0.095 150.6
1889 10:09:05.3 N5921_2 5|0.074 62.7 0.084 24.3 0.114 -73.1 0.093 47.3 0.066 119.9 0.069 154.9 0.099 81.2 0.085 147.4
1890 10:09:05.3 N5921_2 6|0.079 44.4 0.081 21.7 0.092 -66.3 0.101 48.0 0.089 125.6 0.060 154.0 0.099 83.1 0.097 152.7
1891 | Ant = 5 | Ant = 10 | Ant = 11 | Ant = 12 |
1892 Time Field Chn| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F|
1893 ----------|---------------|---|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|
1894 09:21:46.0 1331+30500002_0 4|0.261 -26.0 0.285 -107.1 0.279 -149.5 0.263 2.9 0.274 -102.5 0.257 -7.0 0.289 174.3 0.309 -139.2
1895 09:21:46.0 1331+30500002_0 5|0.269 -26.1 0.295 -107.2 0.288 -148.8 0.274 2.3 0.283 -100.9 0.271 -6.8 0.307 173.1 0.319 -138.2
1896 09:21:46.0 1331+30500002_0 6|0.272 -26.1 0.300 -107.0 0.293 -148.7 0.281 2.0 0.287 -99.7 0.280 -6.7 0.312 171.2 0.326 -137.2
1897 10:05:27.9 1445+09900002_0 4|0.416 -24.0 0.450 -106.4 0.437 -147.3 0.414 3.2 0.433 -99.6 0.412 -6.8 0.456 175.9 0.477 -140.0
1898 10:05:27.9 1445+09900002_0 5|0.421 -22.6 0.478 -106.1 0.453 -147.4 0.433 2.0 0.453 -98.1 0.433 -6.7 0.481 174.4 0.491 -138.9
1899 10:05:27.9 1445+09900002_0 6|0.436 -22.7 0.478 -106.7 0.459 -146.6 0.443 2.4 0.457 -97.1 0.450 -7.0 0.486 173.5 0.510 -137.7
1900 10:09:05.3 N5921_2 4|0.074 95.0 0.085 -4.2 0.083 109.6 0.084 -116.6 0.081 63.2 0.071 131.2 0.050 -55.4 0.083 -27.4
1901 10:09:05.3 N5921_2 5|0.071 96.8 0.084 -13.7 0.086 104.3 0.100 -116.4 0.099 61.7 0.084 145.1 0.091 -76.1 0.087 -33.6
1902 10:09:05.3 N5921_2 6|0.082 84.9 0.078 -5.3 0.101 109.1 0.102 -109.9 0.087 60.1 0.107 130.4 0.085 -75.5 0.080 -31.2
1903 | Ant = 13 | Ant = 20 | Ant = 21 | Ant = 22 |
1904 Time Field Chn| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F| Amp Phs F Amp Phs F|
1905 ----------|---------------|---|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|
1906 09:21:46.0 1331+30500002_0 4|0.285 -169.5 0.277 -90.4 0.254 -36.0 0.290 70.9 0.286 -97.8 0.305 108.8 0.273 -84.6 0.224 -124.2
1907 09:21:46.0 1331+30500002_0 5|0.296 -168.9 0.287 -90.5 0.269 -38.6 0.300 71.0 0.296 -97.8 0.317 108.2 0.284 -85.8 0.243 -127.6
1908 09:21:46.0 1331+30500002_0 6|0.301 -168.7 0.291 -90.3 0.278 -39.9 0.306 70.9 0.302 -97.8 0.326 107.2 0.289 -86.6 0.255 -129.7
1909 10:05:27.9 1445+09900002_0 4|0.448 -167.2 0.434 -90.7 0.401 -34.4 0.456 70.8 0.457 -95.5 0.485 108.9 0.431 -82.1 0.361 -123.9
1910 10:05:27.9 1445+09900002_0 5|0.466 -166.5 0.457 -91.1 0.423 -36.6 0.470 70.8 0.471 -96.6 0.506 108.1 0.448 -83.2 0.393 -126.7
1911 10:05:27.9 1445+09900002_0 6|0.473 -166.9 0.464 -91.1 0.436 -37.8 0.485 70.2 0.476 -96.6 0.521 108.0 0.447 -83.2 0.410 -130.0
1912 10:09:05.3 N5921_2 4|0.097 83.0 0.087 143.5 0.080 43.1 0.094 144.2 0.087 168.7 0.092 1.4 0.111 76.1 0.079 18.9
1913 10:09:05.3 N5921_2 5|0.100 87.4 0.094 137.0 0.061 54.7 0.098 153.3 0.094 178.6 0.096 -3.7 0.101 64.6 0.091 9.5
1914 10:09:05.3 N5921_2 6|0.099 93.3 0.122 140.5 0.077 51.3 0.090 151.7 0.083 -179.6 0.100 2.2 0.095 61.3 0.108 0.4
1916 Listed 108 antenna solutions.
1918 --------------------------------------------------------------------------------
1920 """
1921 return _calibrater.calibrater_listcal(self, *args, **kwargs)
1924 def posangcal(self, *args, **kwargs):
1925 """
1926 posangcal(self, _posangcor, _tablein, _tableout) -> bool
1930 Summary:
1931 Apply position angle calibration to an existing cal table
1933 Description:
1937 This function is used to apply position angle calibration for
1938 observations made using circularly polarized feeds. According to the
1939 Measurement Equation formalism, this correction should be applied to a
1940 {tt D} (instrumental polarization) calibration table.
1942 If no {tt D} calibration is performed (and thus no such table is
1943 available), the correction can be applied to a {tt G} table, but it
1944 should NEVER be applied to both, and always applied to a {tt D} table
1945 if one is available. An input table must be specified. If no output
1946 table is specified, then the input table will be modified in place.
1948 Specify, as a vector of values, a position angle adjustment (in degrees)
1949 for each spectral window. If only one value is specified, it will be
1950 duplicated to all spectral windows; otherwise, the number of values
1951 specified must match the number of spectral windows. The sign
1952 convention for the position angle adjustment is such that the specified
1953 value is the that which, when added to the position angle implied by the
1954 data, will yield the correct position angle. For example, if {tt G-},
1955 {tt D-}, and {tt P-}calibrated data for 3c286 suggests a position
1956 angle of 45 degrees, the posangcor value should be -12 degrees as this
1957 will yield the correct position angle of 33 degrees when added. In
1958 general, posangcor equals correct position angle minus observed position
1959 angle.
1961 A future version of this function will have an option to recognize
1962 standard position angle calibrators and determine the correction
1963 automatically.
1965 (NB: It may be desirable to use solutions for 'X' to handle
1966 position angle calibration, rather than this method.)
1968 Input Parameters:
1969 posangcor Position angle corrections (degrees)
1970 tablein Input calibration table name
1971 tableout Output calibration table name. Default is input table name.
1973 Example:
1975 cb.open('polcal.ms');
1976 cb.posangcal(tablein='3C286.dcal', tableout='3C286.dpacal',
1977 posangcor=[-12.0, 54.0]);
1978 cb.close();
1981 This example takes an existing calibration table containing {tt D}
1982 Jones matrices, and applies a position angle calibration of 45 and 54
1983 degrees to spectral windows 1 & 2, respectively, writing the result
1984 to a new table. The observed position angles for 3C286 must have been
1985 45 and -21 degrees; the corrections specified yield the correct value
1986 of 33 degrees when added to the observed values.
1988 --------------------------------------------------------------------------------
1990 """
1991 return _calibrater.calibrater_posangcal(self, *args, **kwargs)
1994 def linpolcor(self, *args, **kwargs):
1995 """
1996 linpolcor(self, _tablein, _tableout, _fields) -> bool
2000 Summary:
2001 Correct the gain table for linear polarization of the calibrator
2003 Description:
2007 THIS METHOD IS CURRENTLY DISABLED.
2009 This function can be used to correct the gains derived from secondary
2010 calibrators with unknown or variable polarization. It should only be
2011 used for arrays with linear (X/Y) feeds and an Alt-Az mount for which
2012 the observed polarization varies with feed position angle on the sky.
2014 The function fits the gains with a sine and cosine term in feed position
2015 angle and extracts the Q and U components of the secondary calibrator.
2016 This is only possible if there is sufficient range in the position angle
2017 (i.e., minimum of about 6 scans spanning at least 90 degrees in position
2018 angle). Check the error of the fit to judge if the fit was succesfull,
2019 it should generally be smaller than 0.5%.
2021 Use the {stfaf fields} argument to select calibrator fields to be
2022 fitted. The function takes a calibration table as input, and can write
2023 the adjusted gain solutions to the same table on output, or create a new
2024 table containing these results. The function also prints the derived
2025 polarization for each field for each spectral window.
2027 Input Parameters:
2028 tablein Input calibration table name
2029 tableout Output calibration table name
2030 fields Calibrator field names
2032 Example:
2034 cb.open('atca.ms');
2035 cb.linpolcor(tablein='atca.gcal', tableout='atca.gcal2',
2036 fields='2254-367');
2037 cb.close();
2040 This example takes an existing calibration table containing {tt G}
2041 Jones matrices, and writes a corrected output table, correcting only
2042 gains derived from 2254-367 for linear polarization.
2044 --------------------------------------------------------------------------------
2046 """
2047 return _calibrater.calibrater_linpolcor(self, *args, **kwargs)
2050 def plotcal(self, *args, **kwargs):
2051 """
2052 plotcal(self, _antennas, _fields, _spwids, _plottype, _tablename, _polarization, _multiplot, _nx, _ny, _psfile) -> bool
2056 Summary:
2057 Plot a calibration table
2059 Description:
2063 This function plots a calibration table either to a plotter or
2064 to a file.
2066 The argument {stfaf plottype} can take the following values
2067 for all types of solutions:
2068 begin{description}
2069 item[AMP] Gain Amplitude vs. Time
2070 item[1/AMP] Inverse Gain Amplitude vs. Time (useful for
2071 comparing with classic AIPS)
2072 item[PHASE] Gain Phase vs. Time
2073 item[RI] Gain Real vs. Imaginary
2074 item[RLPHASE] Right/Left Gain phase difference (if polarizations are R,L)
2075 item[XYPHASE] X/Y Gain phase difference (if polarizations are X,Y)
2076 end{description}
2078 The argument {stfaf plottype} can take the following values
2079 for D tables
2081 begin{description}
2082 item[DAMP] Cross-polarized Gain Amplitude vs. Time
2083 item[DPHASE] Cross-polarized Gain Phase vs. Time
2084 item[DRI] Cross-polarized Gain Real vs. Imaginary
2085 end{description}
2087 The quality of the solutions can be examined with the following
2088 {stfaf plottype} choices:
2089 begin{description}
2090 item[FIT] Fit per spectral window
2091 item[FITWGT] Fit weight per spectral window
2092 item[TOTALFIT] Total fit
2093 end{description}
2095 By default, all antennas (as specified in the antennas argument) will
2096 appear on the same plot. Separate plots (all with the same scale)
2097 for each antenna can be activated by setting multiplot=T. The multiplot
2098 argument only separates plots by antenna (not, e.g., by the field_id(s)
2099 specified in the fields argument). If multiplot=T, the nx and ny
2100 arguments can be used to specify the number of plots per page.
2102 At the moment, only one polarization can be plotted per execution.
2103 This restriction will be relaxed in the near future.
2105 For B solutions, the plotting will loop over timestamps (if more than
2106 one).
2108 A hardcopy plot can be created by specifying the texttt{psfile}
2109 argument (which is especially useful for batch processing when a
2110 display screen is not available). This will cause the plot to be
2111 written to a PostScript file which can be subsequently sent to a
2112 printer.
2114 Input Parameters:
2115 antennas Antennas to plot. Default is none.
2116 fields Fields to plot. Default is none.
2117 spwids Spectral windows id.'s to plot. Default is none.
2118 plottype Plot type
2119 tablename Calibration table name
2120 polarization Polarization to plot
2121 multiplot Turn on separate antenna plots
2122 nx If multiplot=T, number of plots on horizontal axis
2123 ny If multiplot=T, number of plots on vertical axis
2124 psfile Name of output PostScript file to write plot to. Default is to send plot to the screen.
2126 Example:
2128 cb.open('ngc5921.ms');
2129 cb.plotcal(plottype='PHASE', tablename='gcal', antennas=[1,3], polarization=2);
2130 cb.close();
2132 --------------------------------------------------------------------------------
2134 """
2135 return _calibrater.calibrater_plotcal(self, *args, **kwargs)
2138 def modelfit(self, *args, **kwargs):
2139 """
2140 modelfit(self, _vary, _niter, _compshape, _par, _file) -> std::vector< double >
2144 Summary:
2145 Model fitting
2147 Description:
2151 This method fits single-component models (points, elliptical Gaussians or elliptical Disks_
2152 to the CORRECTED_DATA of the selected field. A first guess for the component
2153 parameters may be specified in the {stfaf par} parameter.
2155 Input Parameters:
2156 vary If specified where T, let this parameter (in par) vary in fit
2157 niter Number of non-linear fitting iterations
2158 compshape Component shape, P=point G=gaussian
2159 par Initial guess for fit parameters (default is for 'P)'I flux, rel RA, rel Dec, 1,0, 0.0, 0.0 are defaults
2160 file If specified, output componentslist file name, if empty don't write componentslist file
2162 Example:
2164 cb.open('ngc5921.ms');
2165 cb.selectvis(field='1331*')
2166 cb.modelfit(compshape='P',par=[15.0,0.0,0.0])
2167 cb.close();
2170 This example fits a point source mode using 15.0 Jy at the origin (phase center)
2171 as a first guess.
2175 cb.open('ngc5921.ms');
2176 cb.selectvis(field='1331*')
2177 cb.modelfit(compshape='G',par=[15.0,0.0,0.0,2.0,1.0,0.0])
2178 cb.close();
2181 This example fits a Guassian model with a starting
2182 guess of 15 Jy at the phase center (0,0), with 2.0 arcsec major axis,
2183 1.0 axial ratio, at position angle 0.0 deg.
2185 --------------------------------------------------------------------------------
2187 """
2188 return _calibrater.calibrater_modelfit(self, *args, **kwargs)
2191 def createcaltable(self, *args, **kwargs):
2192 """
2193 createcaltable(self, _caltable, _partype, _caltype, _singlechan) -> bool
2197 Summary:
2198 Create an empty calibration table
2200 Description:
2203 Creates an empty calibration table that can subsequently be filled
2204 with by using the table tool.
2206 Input Parameters:
2207 caltable Calibration table name
2208 partype Parameter type name
2209 caltype Calibration type name
2210 singlechan Create a calibration table with frequency-independent parameters?
2212 Example:
2214 cb.open('ngc5921.ms',F,F,F) # don't add MODEL_DATA, etc.
2215 cb.createcaltable('ngc5921.gcal', 'Complex', 'G Jones', True)
2216 cb.close()
2218 --------------------------------------------------------------------------------
2220 """
2221 return _calibrater.calibrater_createcaltable(self, *args, **kwargs)
2224 def updatecaltable(self, *args, **kwargs):
2225 """
2226 updatecaltable(self, _caltable) -> bool
2230 Summary:
2231 Caltable modernizer.
2233 Description:
2236 This method can be used to update a caltable (from v3.4 or later)
2237 to the current version of CASA.
2239 The following updates are currently supported.
2241 o At CASA v4.1.0, the OBSERVATION subtable and OBSERVATION_ID column
2242 were added to caltables. This method adds trivial versions of
2243 these elements to pre-v4.1 caltables.
2245 Input Parameters:
2246 caltable Name of the caltable.
2248 Example:
2250 cb.updatecaltable('mycaltable');
2252 --------------------------------------------------------------------------------
2254 """
2255 return _calibrater.calibrater_updatecaltable(self, *args, **kwargs)
2258 def close(self):
2259 """
2260 close(self) -> bool
2264 Summary:
2265 Close the calibrater tool
2267 Description:
2270 Close the {tt calibrater} tool, which is hardly ever necessary.
2272 Example:
2274 cb.open('ngc5921.ms');
2275 cb.close();
2277 --------------------------------------------------------------------------------
2279 """
2280 return _calibrater.calibrater_close(self)
2283 def done(self):
2284 """
2285 done(self) -> bool
2289 Summary:
2290 Destroy the calibrater tool
2292 Description:
2295 This function is redundant with the {stfaf close} method.
2297 Example:
2299 cb.open('ngc5921.ms');
2300 cb.done();
2302 --------------------------------------------------------------------------------
2304 """
2305 return _calibrater.calibrater_done(self)
2308 def parsecallibfile(self, *args, **kwargs):
2309 """
2310 parsecallibfile(self, _filein) -> record *
2314 Summary:
2315 Bootstrap the flux density scale from standard calibrators
2317 Description:
2321 TBD
2323 Input Parameters:
2324 filein Input cal library file name
2326 Example:
2328 TBD
2330 --------------------------------------------------------------------------------
2332 """
2333 return _calibrater.calibrater_parsecallibfile(self, *args, **kwargs)
2336 def setcorrdepflags(self, *args, **kwargs):
2337 """
2338 setcorrdepflags(self, _corrdepflags) -> bool
2342 Summary:
2343 Control use of correlation-dependent flags
2345 Description:
2349 TBD
2351 Input Parameters:
2352 corrdepflags Turn correlation dependent flags on/off (true/false)
2354 Example:
2356 TBD
2358 --------------------------------------------------------------------------------
2360 """
2361 return _calibrater.calibrater_setcorrdepflags(self, *args, **kwargs)
2364 def setvi(self, *args, **kwargs):
2365 """
2366 setvi(self, _old, _quiet) -> bool
2370 Summary:
2371 TEMPORARY method to control use of new VI2 regime
2373 Description:
2376 Use this method to control whether the modern (old=False) or old-style (old=True)
2377 VisibilityIterator is used by the calibration application. General users should
2378 avoid use of this function unless they understand what this means.
2380 This method will be removed from the calibrater tool in v5.1.
2382 Input Parameters:
2383 old Use old-style VI, if old=True, else use new VI2
2384 quiet Warn in logger, if quiet=False
2386 Example:
2388 cb.setvi(True)
2389 cb.open('ngc5921.ms')
2391 --------------------------------------------------------------------------------
2393 """
2394 return _calibrater.calibrater_setvi(self, *args, **kwargs)
2396 __swig_destroy__ = _calibrater.delete_calibrater
2397 __del__ = lambda self: None
2398calibrater_swigregister = _calibrater.calibrater_swigregister
2399calibrater_swigregister(calibrater)
2401# This file is compatible with both classic and new-style classes.