##################### generated by xml-casa (v2) from hif_gaincal.xml ###############
##################### fcac17fa025c16f99e6dcf0f126fc24f ##############################
from __future__ import absolute_import
from casashell.private.stack_manip import find_local as __sf__
from casashell.private.stack_manip import find_frame as _find_frame
from casatools.typecheck import validator as _pc
from casatools.coercetype import coerce as _coerce
from pipeline.hif.cli import hif_gaincal as _hif_gaincal_t
from collections import OrderedDict
import numpy
import sys
import os
import shutil
[docs]def static_var(varname, value):
def decorate(func):
setattr(func, varname, value)
return func
return decorate
class _hif_gaincal:
"""
hif_gaincal ---- Determine temporal gains from calibrator observations
The complex gains are derived from the data column (raw data) divided by the
model column (usually set with hif_setjy). The gains are obtained for a
specified solution interval, spw combination and field combination.
Good candidate reference antennas can be determined using the hif_refant
task.
Previous calibrations that have been stored in the pipeline context are
applied on the fly. Users can interact with these calibrations via the
hif_export_calstate and hif_import_calstate tasks.
Output
results -- If pipeline mode is 'getinputs' then None is returned. Otherwise
the results object for the pipeline task is returned.
Issues
The 'gspline' (smooth) option is still under development in CASA.
--------- parameter descriptions ---------------------------------------------
vis The list of input MeasurementSets. Defaults to the list of
MeasurementSets specified in the h_init or hif_importdata task.
'': use all MeasurementSets in the context
Examples: 'ngc5921.ms', ['ngc5921a.ms', ngc5921b.ms', 'ngc5921c.ms']
caltable The list of output calibration tables. Defaults to the
standard pipeline naming convention.
Example: caltable=['M82.gcal', 'M82B.gcal']
field The list of field names or field ids for which gain solutions
are to be computed. Defaults to all fields with the standard
intent.
Example: field='3C279', field='3C279, M82'
intent A string containing a comma delimited list of intents against
which the selected fields are matched. Defaults to *PHASE*.
Examples: intent='', intent='*AMP*,*PHASE*'
spw The list of spectral windows and channels for which gain
solutions are computed. Defaults to all science spectral
windows.
Examples: spw='3C279', spw='3C279, M82'
antenna Set of data selection antenna ids
hm_gaintype The type of gain calibration. The options are 'gtype' and
'gspline' for CASA gain types = 'G' and 'GSPLINE' respectively.
calmode Type of solution. The options are 'ap' (amp and phase), 'p'
(phase only) and 'a' (amp only).
Examples: calmode='p', calmode='a', calmode='ap'
solint Time solution intervals in CASA syntax. Works for
hm_gaintype='gtype' only.
Examples: solint='inf', solint='int', solint='100sec'
combine Data axes to combine for solving. Options are '', 'scan',
'spw', 'field' or any comma-separated combination. Works for
hm_gaintype='gtype' only.
refant Reference antenna name(s) in priority order. Defaults to most
recent values set in the pipeline context. If no reference
antenna is defined in the pipeline context use the CASA
defaults.
Examples: refant='DV01', refant='DV05,DV07'
refantmode Controls how the refant is applied. Currently available
choices are 'flex', 'strict', and the default value of ''.
Setting to '' allows the pipeline to select the appropriate
mode based on the state of the reference antenna list.
Examples: refantmode='strict', refantmode=''
solnorm Normalize average solution amplitudes to 1.0
minblperant Minimum number of baselines required per antenna for each
solve. Antennas with fewer baselines are excluded from
solutions. Works for hm_gaintype='gtype' only.
minsnr Solutions below this SNR are rejected. Works for
hm_gaintype='channel' only.
smodel Point source Stokes parameters for source model (experimental).
Defaults to using standard MODEL_DATA column data.
Example: smodel=[1,0,0,0] - (I=1, unpolarized)
splinetime Spline timescale (sec). Used for hm_gaintype='gspline'.
Typical splinetime should cover about 3 to 5 calibrator scans.
npointaver Tune phase-unwrapping algorithm. Used for
hm_gaintype='gspline'. Keep at default value.
phasewrap Wrap the phase for changes larger than this amount (degrees).
Used for hm_gaintype='gspline'. Keep at default value.
pipelinemode The pipeline operating mode.
In 'automatic' mode the pipeline determines the values of all
context defined pipeline inputs automatically.
In 'interactive' mode the user can set the pipeline context
defined parameters manually.
In 'getinputs' mode the user can check the settings of all
pipeline parameters without running the task.
dryrun Run the task (False) or just display the command (True)
acceptresults Add the results of the task to the pipeline context (True) or
reject them (False).
--------- examples -----------------------------------------------------------
Compute standard per scan gain solutions that will be used to calibrate
the target:
hif_gaincal()
"""
_info_group_ = """pipeline"""
_info_desc_ = """Determine temporal gains from calibrator observations"""
__schema = {'vis': {'type': 'cStrVec', 'coerce': [_coerce.to_list,_coerce.to_strvec]}, 'caltable': {'type': 'cStrVec', 'coerce': [_coerce.to_list,_coerce.to_strvec]}, 'field': {'type': 'cStr', 'coerce': _coerce.to_str}, 'intent': {'type': 'cStr', 'coerce': _coerce.to_str}, 'spw': {'type': 'cStr', 'coerce': _coerce.to_str}, 'antenna': {'type': 'cStr', 'coerce': _coerce.to_str}, 'hm_gaintype': {'type': 'cStr', 'coerce': _coerce.to_str, 'allowed': [ 'gtype', 'gspline' ]}, 'calmode': {'type': 'cStr', 'coerce': _coerce.to_str, 'allowed': [ 'a', 'p', 'ap' ]}, 'solint': {'type': 'cVariant', 'coerce': [_coerce.to_variant]}, 'combine': {'type': 'cStr', 'coerce': _coerce.to_str}, 'refant': {'type': 'cStr', 'coerce': _coerce.to_str}, 'refantmode': {'type': 'cStr', 'coerce': _coerce.to_str, 'allowed': [ '', 'flex', 'strict' ]}, 'solnorm': {'type': 'cBool'}, 'minblperant': {'type': 'cInt'}, 'minsnr': {'type': 'cFloat', 'coerce': _coerce.to_float}, 'smodel': {'type': 'cFloatVec', 'coerce': [_coerce.to_list,_coerce.to_floatvec]}, 'splinetime': {'type': 'cFloat', 'coerce': _coerce.to_float}, 'npointaver': {'type': 'cInt'}, 'phasewrap': {'type': 'cFloat', 'coerce': _coerce.to_float}, 'pipelinemode': {'type': 'cStr', 'coerce': _coerce.to_str, 'allowed': [ 'automatic', 'interactive', 'getinputs' ]}, 'dryrun': {'type': 'cBool'}, 'acceptresults': {'type': 'cBool'}}
def __init__(self):
self.__stdout = None
self.__stderr = None
self.__root_frame_ = None
def __globals_(self):
if self.__root_frame_ is None:
self.__root_frame_ = _find_frame( )
assert self.__root_frame_ is not None, "could not find CASAshell global frame"
return self.__root_frame_
def __to_string_(self,value):
if type(value) is str:
return "'%s'" % value
else:
return str(value)
def __validate_(self,doc,schema):
return _pc.validate(doc,schema)
def __do_inp_output(self,param_prefix,description_str,formatting_chars):
out = self.__stdout or sys.stdout
description = description_str.split( )
prefix_width = 23 + 16 + 4
output = [ ]
addon = ''
first_addon = True
while len(description) > 0:
## starting a new line.....................................................................
if len(output) == 0:
## for first line add parameter information............................................
if len(param_prefix)-formatting_chars > prefix_width - 1:
output.append(param_prefix)
continue
addon = param_prefix + ' #'
first_addon = True
addon_formatting = formatting_chars
else:
## for subsequent lines space over prefix width........................................
addon = (' ' * prefix_width) + '#'
first_addon = False
addon_formatting = 0
## if first word of description puts us over the screen width, bail........................
if len(addon + description[0]) - addon_formatting + 1 > self.term_width:
## if we're doing the first line make sure it's output.................................
if first_addon: output.append(addon)
break
while len(description) > 0:
## if the next description word puts us over break for the next line...................
if len(addon + description[0]) - addon_formatting + 1 > self.term_width: break
addon = addon + ' ' + description[0]
description.pop(0)
output.append(addon)
out.write('\n'.join(output) + '\n')
#--------- return nonsubparam values ----------------------------------------------
def __calmode_dflt( self, glb ):
return 'ap'
def __calmode( self, glb ):
if 'calmode' in glb: return glb['calmode']
return 'ap'
def __hm_gaintype_dflt( self, glb ):
return 'gtype'
def __hm_gaintype( self, glb ):
if 'hm_gaintype' in glb: return glb['hm_gaintype']
return 'gtype'
def __pipelinemode_dflt( self, glb ):
return 'automatic'
def __pipelinemode( self, glb ):
if 'pipelinemode' in glb: return glb['pipelinemode']
return 'automatic'
#--------- return inp/go default --------------------------------------------------
def __antenna_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return ""
if self.__pipelinemode( glb ) == "getinputs": return ""
return None
def __phasewrap_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gspline": return float(180.0)
return None
def __dryrun_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return bool(False)
return None
def __field_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return ""
if self.__pipelinemode( glb ) == "getinputs": return ""
return None
def __splinetime_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gspline": return float(3600.0)
return None
def __intent_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return ""
if self.__pipelinemode( glb ) == "getinputs": return ""
return None
def __npointaver_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gspline": return int(3)
return None
def __refant_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return ""
if self.__pipelinemode( glb ) == "getinputs": return ""
return None
def __minsnr_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gtype": return float(3.0)
return None
def __vis_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return []
if self.__pipelinemode( glb ) == "getinputs": return []
return None
def __acceptresults_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return bool(True)
return None
def __minblperant_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gtype": return int(4)
return None
def __solnorm_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return bool(False)
if self.__pipelinemode( glb ) == "getinputs": return bool(False)
return None
def __combine_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gtype": return ""
return None
def __refantmode_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return ""
if self.__pipelinemode( glb ) == "getinputs": return ""
return None
def __solint_dflt( self, glb ):
if self.__hm_gaintype( glb ) == "gtype": return "inf"
return None
def __caltable_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return []
if self.__pipelinemode( glb ) == "getinputs": return []
return None
def __smodel_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return []
if self.__pipelinemode( glb ) == "getinputs": return []
return None
def __spw_dflt( self, glb ):
if self.__pipelinemode( glb ) == "interactive": return ""
if self.__pipelinemode( glb ) == "getinputs": return ""
return None
#--------- return subparam values -------------------------------------------------
def __vis( self, glb ):
if 'vis' in glb: return glb['vis']
dflt = self.__vis_dflt( glb )
if dflt is not None: return dflt
return [ ]
def __caltable( self, glb ):
if 'caltable' in glb: return glb['caltable']
dflt = self.__caltable_dflt( glb )
if dflt is not None: return dflt
return [ ]
def __field( self, glb ):
if 'field' in glb: return glb['field']
dflt = self.__field_dflt( glb )
if dflt is not None: return dflt
return ''
def __intent( self, glb ):
if 'intent' in glb: return glb['intent']
dflt = self.__intent_dflt( glb )
if dflt is not None: return dflt
return ''
def __spw( self, glb ):
if 'spw' in glb: return glb['spw']
dflt = self.__spw_dflt( glb )
if dflt is not None: return dflt
return ''
def __antenna( self, glb ):
if 'antenna' in glb: return glb['antenna']
dflt = self.__antenna_dflt( glb )
if dflt is not None: return dflt
return ''
def __solint( self, glb ):
if 'solint' in glb: return glb['solint']
dflt = self.__solint_dflt( glb )
if dflt is not None: return dflt
return 'inf'
def __combine( self, glb ):
if 'combine' in glb: return glb['combine']
dflt = self.__combine_dflt( glb )
if dflt is not None: return dflt
return ''
def __refant( self, glb ):
if 'refant' in glb: return glb['refant']
dflt = self.__refant_dflt( glb )
if dflt is not None: return dflt
return ''
def __refantmode( self, glb ):
if 'refantmode' in glb: return glb['refantmode']
dflt = self.__refantmode_dflt( glb )
if dflt is not None: return dflt
return ''
def __solnorm( self, glb ):
if 'solnorm' in glb: return glb['solnorm']
dflt = self.__solnorm_dflt( glb )
if dflt is not None: return dflt
return False
def __minblperant( self, glb ):
if 'minblperant' in glb: return glb['minblperant']
dflt = self.__minblperant_dflt( glb )
if dflt is not None: return dflt
return int(4)
def __minsnr( self, glb ):
if 'minsnr' in glb: return glb['minsnr']
dflt = self.__minsnr_dflt( glb )
if dflt is not None: return dflt
return float(3.0)
def __smodel( self, glb ):
if 'smodel' in glb: return glb['smodel']
dflt = self.__smodel_dflt( glb )
if dflt is not None: return dflt
return [ ]
def __splinetime( self, glb ):
if 'splinetime' in glb: return glb['splinetime']
dflt = self.__splinetime_dflt( glb )
if dflt is not None: return dflt
return float(3600.0)
def __npointaver( self, glb ):
if 'npointaver' in glb: return glb['npointaver']
dflt = self.__npointaver_dflt( glb )
if dflt is not None: return dflt
return int(3)
def __phasewrap( self, glb ):
if 'phasewrap' in glb: return glb['phasewrap']
dflt = self.__phasewrap_dflt( glb )
if dflt is not None: return dflt
return float(180.0)
def __dryrun( self, glb ):
if 'dryrun' in glb: return glb['dryrun']
dflt = self.__dryrun_dflt( glb )
if dflt is not None: return dflt
return False
def __acceptresults( self, glb ):
if 'acceptresults' in glb: return glb['acceptresults']
dflt = self.__acceptresults_dflt( glb )
if dflt is not None: return dflt
return True
#--------- subparam inp output ----------------------------------------------------
def __vis_inp(self):
if self.__vis_dflt( self.__globals_( ) ) is not None:
description = 'List of input MeasurementSets'
value = self.__vis( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'vis': value},{'vis': self.__schema['vis']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('vis',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __caltable_inp(self):
if self.__caltable_dflt( self.__globals_( ) ) is not None:
description = 'List of output caltables'
value = self.__caltable( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'caltable': value},{'caltable': self.__schema['caltable']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('caltable',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __field_inp(self):
if self.__field_dflt( self.__globals_( ) ) is not None:
description = 'Set of data selection field names or ids'
value = self.__field( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'field': value},{'field': self.__schema['field']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('field',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __intent_inp(self):
if self.__intent_dflt( self.__globals_( ) ) is not None:
description = 'Set of data selection observing intents'
value = self.__intent( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'intent': value},{'intent': self.__schema['intent']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('intent',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __spw_inp(self):
if self.__spw_dflt( self.__globals_( ) ) is not None:
description = 'Set of data selection spectral window/channels'
value = self.__spw( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'spw': value},{'spw': self.__schema['spw']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('spw',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __antenna_inp(self):
if self.__antenna_dflt( self.__globals_( ) ) is not None:
description = 'Set of data selection antenna ids'
value = self.__antenna( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'antenna': value},{'antenna': self.__schema['antenna']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('antenna',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __hm_gaintype_inp(self):
description = 'The gain solution type (gtype or gspline)'
value = self.__hm_gaintype( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'hm_gaintype': value},{'hm_gaintype': self.__schema['hm_gaintype']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output('\x1B[1m\x1B[47m%-16.16s =\x1B[0m %s%-23s%s' % ('hm_gaintype',pre,self.__to_string_(value),post),description,13+len(pre)+len(post))
def __calmode_inp(self):
description = 'Type of solution (ap, p, a)'
value = self.__calmode( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'calmode': value},{'calmode': self.__schema['calmode']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output('%-16.16s = %s%-23s%s' % ('calmode',pre,self.__to_string_(value),post),description,0+len(pre)+len(post))
def __solint_inp(self):
if self.__solint_dflt( self.__globals_( ) ) is not None:
description = 'Solution intervals'
value = self.__solint( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'solint': value},{'solint': self.__schema['solint']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('solint',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __combine_inp(self):
if self.__combine_dflt( self.__globals_( ) ) is not None:
description = 'Data axes which to combine for solve (scan, spw, and/or field)'
value = self.__combine( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'combine': value},{'combine': self.__schema['combine']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('combine',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __refant_inp(self):
if self.__refant_dflt( self.__globals_( ) ) is not None:
description = 'Reference antenna names'
value = self.__refant( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'refant': value},{'refant': self.__schema['refant']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('refant',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __refantmode_inp(self):
if self.__refantmode_dflt( self.__globals_( ) ) is not None:
description = 'Reference antenna selection mode'
value = self.__refantmode( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'refantmode': value},{'refantmode': self.__schema['refantmode']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('refantmode',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __solnorm_inp(self):
if self.__solnorm_dflt( self.__globals_( ) ) is not None:
description = 'Normalize average solution amplitudes to 1.0'
value = self.__solnorm( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'solnorm': value},{'solnorm': self.__schema['solnorm']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('solnorm',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __minblperant_inp(self):
if self.__minblperant_dflt( self.__globals_( ) ) is not None:
description = 'Minimum baselines per antenna required for solve'
value = self.__minblperant( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'minblperant': value},{'minblperant': self.__schema['minblperant']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('minblperant',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __minsnr_inp(self):
if self.__minsnr_dflt( self.__globals_( ) ) is not None:
description = 'Reject solutions below this SNR'
value = self.__minsnr( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'minsnr': value},{'minsnr': self.__schema['minsnr']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('minsnr',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __smodel_inp(self):
if self.__smodel_dflt( self.__globals_( ) ) is not None:
description = 'Point source Stokes parameters for source model'
value = self.__smodel( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'smodel': value},{'smodel': self.__schema['smodel']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('smodel',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __splinetime_inp(self):
if self.__splinetime_dflt( self.__globals_( ) ) is not None:
description = 'Spline timescale(sec)'
value = self.__splinetime( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'splinetime': value},{'splinetime': self.__schema['splinetime']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('splinetime',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __npointaver_inp(self):
if self.__npointaver_dflt( self.__globals_( ) ) is not None:
description = 'The phase-unwrapping algorithm'
value = self.__npointaver( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'npointaver': value},{'npointaver': self.__schema['npointaver']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('npointaver',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __phasewrap_inp(self):
if self.__phasewrap_dflt( self.__globals_( ) ) is not None:
description = 'Wrap the phase for jumps greater than this value (degrees)'
value = self.__phasewrap( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'phasewrap': value},{'phasewrap': self.__schema['phasewrap']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('phasewrap',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __pipelinemode_inp(self):
description = 'The pipeline operating mode'
value = self.__pipelinemode( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'pipelinemode': value},{'pipelinemode': self.__schema['pipelinemode']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output('\x1B[1m\x1B[47m%-16.16s =\x1B[0m %s%-23s%s' % ('pipelinemode',pre,self.__to_string_(value),post),description,13+len(pre)+len(post))
def __dryrun_inp(self):
if self.__dryrun_dflt( self.__globals_( ) ) is not None:
description = 'Run the task (False) or just display the command (True)'
value = self.__dryrun( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'dryrun': value},{'dryrun': self.__schema['dryrun']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('dryrun',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
def __acceptresults_inp(self):
if self.__acceptresults_dflt( self.__globals_( ) ) is not None:
description = 'Add the results to the pipeline context'
value = self.__acceptresults( self.__globals_( ) )
(pre,post) = ('','') if self.__validate_({'acceptresults': value},{'acceptresults': self.__schema['acceptresults']}) else ('\x1B[91m','\x1B[0m')
self.__do_inp_output(' \x1B[92m%-13.13s =\x1B[0m %s%-23s%s' % ('acceptresults',pre,self.__to_string_(value),post),description,9+len(pre)+len(post))
#--------- global default implementation-------------------------------------------
@static_var('state', __sf__('casa_inp_go_state'))
def set_global_defaults(self):
self.set_global_defaults.state['last'] = self
glb = self.__globals_( )
if 'antenna' in glb: del glb['antenna']
if 'phasewrap' in glb: del glb['phasewrap']
if 'dryrun' in glb: del glb['dryrun']
if 'field' in glb: del glb['field']
if 'pipelinemode' in glb: del glb['pipelinemode']
if 'splinetime' in glb: del glb['splinetime']
if 'intent' in glb: del glb['intent']
if 'npointaver' in glb: del glb['npointaver']
if 'hm_gaintype' in glb: del glb['hm_gaintype']
if 'refant' in glb: del glb['refant']
if 'minsnr' in glb: del glb['minsnr']
if 'vis' in glb: del glb['vis']
if 'acceptresults' in glb: del glb['acceptresults']
if 'minblperant' in glb: del glb['minblperant']
if 'solnorm' in glb: del glb['solnorm']
if 'calmode' in glb: del glb['calmode']
if 'combine' in glb: del glb['combine']
if 'refantmode' in glb: del glb['refantmode']
if 'solint' in glb: del glb['solint']
if 'caltable' in glb: del glb['caltable']
if 'smodel' in glb: del glb['smodel']
if 'spw' in glb: del glb['spw']
#--------- inp function -----------------------------------------------------------
def inp(self):
print("# hif_gaincal -- %s" % self._info_desc_)
self.term_width, self.term_height = shutil.get_terminal_size(fallback=(80, 24))
self.__vis_inp( )
self.__caltable_inp( )
self.__field_inp( )
self.__intent_inp( )
self.__spw_inp( )
self.__antenna_inp( )
self.__hm_gaintype_inp( )
self.__calmode_inp( )
self.__solint_inp( )
self.__combine_inp( )
self.__refant_inp( )
self.__refantmode_inp( )
self.__solnorm_inp( )
self.__minblperant_inp( )
self.__minsnr_inp( )
self.__smodel_inp( )
self.__splinetime_inp( )
self.__npointaver_inp( )
self.__phasewrap_inp( )
self.__pipelinemode_inp( )
self.__dryrun_inp( )
self.__acceptresults_inp( )
#--------- tget function ----------------------------------------------------------
@static_var('state', __sf__('casa_inp_go_state'))
def tget(self,file=None):
from casashell.private.stack_manip import find_frame
from runpy import run_path
filename = None
if file is None:
if os.path.isfile("hif_gaincal.last"):
filename = "hif_gaincal.last"
elif isinstance(file, str):
if os.path.isfile(file):
filename = file
if filename is not None:
glob = find_frame( )
newglob = run_path( filename, init_globals={ } )
for i in newglob:
glob[i] = newglob[i]
self.tget.state['last'] = self
else:
print("could not find last file, setting defaults instead...")
self.set_global_defaults( )
def __call__( self, vis=None, caltable=None, field=None, intent=None, spw=None, antenna=None, hm_gaintype=None, calmode=None, solint=None, combine=None, refant=None, refantmode=None, solnorm=None, minblperant=None, minsnr=None, smodel=None, splinetime=None, npointaver=None, phasewrap=None, pipelinemode=None, dryrun=None, acceptresults=None ):
def noobj(s):
if s.startswith('<') and s.endswith('>'):
return "None"
else:
return s
_prefile = os.path.realpath('hif_gaincal.pre')
_postfile = os.path.realpath('hif_gaincal.last')
_return_result_ = None
_arguments = [vis,caltable,field,intent,spw,antenna,hm_gaintype,calmode,solint,combine,refant,refantmode,solnorm,minblperant,minsnr,smodel,splinetime,npointaver,phasewrap,pipelinemode,dryrun,acceptresults]
_invocation_parameters = OrderedDict( )
if any(map(lambda x: x is not None,_arguments)):
# invoke python style
# set the non sub-parameters that are not None
local_global = { }
if hm_gaintype is not None: local_global['hm_gaintype'] = hm_gaintype
if calmode is not None: local_global['calmode'] = calmode
if pipelinemode is not None: local_global['pipelinemode'] = pipelinemode
# the invocation parameters for the non-subparameters can now be set - this picks up those defaults
_invocation_parameters['hm_gaintype'] = self.__hm_gaintype( local_global )
_invocation_parameters['calmode'] = self.__calmode( local_global )
_invocation_parameters['pipelinemode'] = self.__pipelinemode( local_global )
# the sub-parameters can then be set. Use the supplied value if not None, else the function, which gets the appropriate default
_invocation_parameters['vis'] = self.__vis( _invocation_parameters ) if vis is None else vis
_invocation_parameters['caltable'] = self.__caltable( _invocation_parameters ) if caltable is None else caltable
_invocation_parameters['field'] = self.__field( _invocation_parameters ) if field is None else field
_invocation_parameters['intent'] = self.__intent( _invocation_parameters ) if intent is None else intent
_invocation_parameters['spw'] = self.__spw( _invocation_parameters ) if spw is None else spw
_invocation_parameters['antenna'] = self.__antenna( _invocation_parameters ) if antenna is None else antenna
_invocation_parameters['solint'] = self.__solint( _invocation_parameters ) if solint is None else solint
_invocation_parameters['combine'] = self.__combine( _invocation_parameters ) if combine is None else combine
_invocation_parameters['refant'] = self.__refant( _invocation_parameters ) if refant is None else refant
_invocation_parameters['refantmode'] = self.__refantmode( _invocation_parameters ) if refantmode is None else refantmode
_invocation_parameters['solnorm'] = self.__solnorm( _invocation_parameters ) if solnorm is None else solnorm
_invocation_parameters['minblperant'] = self.__minblperant( _invocation_parameters ) if minblperant is None else minblperant
_invocation_parameters['minsnr'] = self.__minsnr( _invocation_parameters ) if minsnr is None else minsnr
_invocation_parameters['smodel'] = self.__smodel( _invocation_parameters ) if smodel is None else smodel
_invocation_parameters['splinetime'] = self.__splinetime( _invocation_parameters ) if splinetime is None else splinetime
_invocation_parameters['npointaver'] = self.__npointaver( _invocation_parameters ) if npointaver is None else npointaver
_invocation_parameters['phasewrap'] = self.__phasewrap( _invocation_parameters ) if phasewrap is None else phasewrap
_invocation_parameters['dryrun'] = self.__dryrun( _invocation_parameters ) if dryrun is None else dryrun
_invocation_parameters['acceptresults'] = self.__acceptresults( _invocation_parameters ) if acceptresults is None else acceptresults
else:
# invoke with inp/go semantics
_invocation_parameters['vis'] = self.__vis( self.__globals_( ) )
_invocation_parameters['caltable'] = self.__caltable( self.__globals_( ) )
_invocation_parameters['field'] = self.__field( self.__globals_( ) )
_invocation_parameters['intent'] = self.__intent( self.__globals_( ) )
_invocation_parameters['spw'] = self.__spw( self.__globals_( ) )
_invocation_parameters['antenna'] = self.__antenna( self.__globals_( ) )
_invocation_parameters['hm_gaintype'] = self.__hm_gaintype( self.__globals_( ) )
_invocation_parameters['calmode'] = self.__calmode( self.__globals_( ) )
_invocation_parameters['solint'] = self.__solint( self.__globals_( ) )
_invocation_parameters['combine'] = self.__combine( self.__globals_( ) )
_invocation_parameters['refant'] = self.__refant( self.__globals_( ) )
_invocation_parameters['refantmode'] = self.__refantmode( self.__globals_( ) )
_invocation_parameters['solnorm'] = self.__solnorm( self.__globals_( ) )
_invocation_parameters['minblperant'] = self.__minblperant( self.__globals_( ) )
_invocation_parameters['minsnr'] = self.__minsnr( self.__globals_( ) )
_invocation_parameters['smodel'] = self.__smodel( self.__globals_( ) )
_invocation_parameters['splinetime'] = self.__splinetime( self.__globals_( ) )
_invocation_parameters['npointaver'] = self.__npointaver( self.__globals_( ) )
_invocation_parameters['phasewrap'] = self.__phasewrap( self.__globals_( ) )
_invocation_parameters['pipelinemode'] = self.__pipelinemode( self.__globals_( ) )
_invocation_parameters['dryrun'] = self.__dryrun( self.__globals_( ) )
_invocation_parameters['acceptresults'] = self.__acceptresults( self.__globals_( ) )
try:
with open(_prefile,'w') as _f:
for _i in _invocation_parameters:
_f.write("%-13s = %s\n" % (_i,noobj(repr(_invocation_parameters[_i]))))
_f.write("#hif_gaincal( ")
count = 0
for _i in _invocation_parameters:
_f.write("%s=%s" % (_i,noobj(repr(_invocation_parameters[_i]))))
count += 1
if count < len(_invocation_parameters): _f.write(",")
_f.write(" )\n")
except: pass
try:
_return_result_ = _hif_gaincal_t( _invocation_parameters['vis'],_invocation_parameters['caltable'],_invocation_parameters['field'],_invocation_parameters['intent'],_invocation_parameters['spw'],_invocation_parameters['antenna'],_invocation_parameters['hm_gaintype'],_invocation_parameters['calmode'],_invocation_parameters['solint'],_invocation_parameters['combine'],_invocation_parameters['refant'],_invocation_parameters['refantmode'],_invocation_parameters['solnorm'],_invocation_parameters['minblperant'],_invocation_parameters['minsnr'],_invocation_parameters['smodel'],_invocation_parameters['splinetime'],_invocation_parameters['npointaver'],_invocation_parameters['phasewrap'],_invocation_parameters['pipelinemode'],_invocation_parameters['dryrun'],_invocation_parameters['acceptresults'] )
except Exception as e:
from traceback import format_exc
from casatasks import casalog
casalog.origin('hif_gaincal')
casalog.post("Exception Reported: Error in hif_gaincal: %s" % str(e),'SEVERE')
casalog.post(format_exc( ))
_return_result_ = False
try:
os.rename(_prefile,_postfile)
except: pass
return _return_result_
hif_gaincal = _hif_gaincal( )