caltabconvert_cli.py

Go to the documentation of this file.

#
# This file was generated using xslt from its XML file
#
# Copyright 2008, Associated Universities Inc., Washington DC
#
import sys
import os
#from casac import *
import casac
import string
import time
import inspect
import gc
import numpy
from odict import odict
from taskmanager import tm
from task_caltabconvert import caltabconvert
class caltabconvert_cli_:
    __name__ = "caltabconvert"
    __async__ = {}
    rkey = None
    i_am_a_casapy_task = None
    # The existence of the i_am_a_casapy_task attribute allows help()
    # (and other) to treat casapy tasks as a special case.

    def __init__(self) :
       self.__bases__ = (caltabconvert_cli_,)
       self.__doc__ = self.__call__.__doc__

       self.parameters={'caltabold':None, 'vis':None, 'ptype':None, 'caltabnew':None,  'async':None}


    def result(self, key=None):
            #### here we will scan the task-ids in __async__
            #### and add any that have completed...
            if key is not None and self.__async__.has_key(key) and self.__async__[key] is not None:
               ret = tm.retrieve(self.__async__[key])
               if ret['state'] == "done" :
                  self.__async__[key] = None
               elif ret['state'] == 'crashed' :
                  self.__async__[key] = None
               return ret
            return None


    def __call__(self, caltabold=None, vis=None, ptype=None, caltabnew=None,  async=None):

        """Convert old-style caltables into new-style caltables.\n
    This task converts old-style (up to CASA 3.3.0) caltables into new-style 
    (CASA 3.4.0 and later) caltables. It is provided as a convenience and 
    is strictly temporary. The information transferred should be enough 
    for most calibration purposes. BPOLY and GSPLINE versions are not 
    supported. Only simple bugs will be fixed. If there are other issues, 
    it is suggested that a new-style caltable be created directly.

    Arguments:

    caltabold -- Name of the old-style caltable.
    default: none
    example: caltabold='gronk.g0'

    vis -- Name of the visibility file (MS) associated with the old-style
        caltable.
    default: none
    example: vis='blurp.ms'

    ptype -- Type of data in the new-format caltable.
    default: "complex"; allowed values: "complex" or "float"
    example: ptype="complex"

    NB: The old-style caltables do not have this information, so it is
    imperative that users get it correct.  "complex" refers to caltables that
    have complex gains (e.g., produced by gaincal, bpcal, etc.).  "float" refers
    to caltables that real numbers such as delays (e.g., produced by gencal).

    caltabnew -- Name of the new-style caltable.
    default: "" --> the suffix ".new" is appended to the name of the old-style
        caltable
    example: caltabold='gronk_new.g0'
  
        """
        if not hasattr(self, "__globals__") or self.__globals__ == None :
           self.__globals__=sys._getframe(len(inspect.stack())-1).f_globals
        #casac = self.__globals__['casac']
        casalog = self.__globals__['casalog']
        #casalog = casac.casac.logsink()
        self.__globals__['__last_task'] = 'caltabconvert'
        self.__globals__['taskname'] = 'caltabconvert'
        ###
        self.__globals__['update_params'](func=self.__globals__['taskname'],printtext=False,ipython_globals=self.__globals__)
        ###
        ###
        #Handle globals or user over-ride of arguments
        #
        function_signature_defaults=dict(zip(self.__call__.func_code.co_varnames,self.__call__.func_defaults))
        useLocalDefaults = False

        for item in function_signature_defaults.iteritems():
                key,val = item
                keyVal = eval(key)
                if (keyVal == None):
                        #user hasn't set it - use global/default
                        pass
                else:
                        #user has set it - use over-ride
                        if (key != 'self') :
                           useLocalDefaults = True

        myparams = {}
        if useLocalDefaults :
           for item in function_signature_defaults.iteritems():
               key,val = item
               keyVal = eval(key)
               exec('myparams[key] = keyVal')
               self.parameters[key] = keyVal
               if (keyVal == None):
                   exec('myparams[key] = '+ key + ' = self.itsdefault(key)')
                   keyVal = eval(key)
                   if(type(keyVal) == dict) :
                      if len(keyVal) > 0 :
                         exec('myparams[key] = ' + key + ' = keyVal[len(keyVal)-1][\'value\']')
                      else :
                         exec('myparams[key] = ' + key + ' = {}')

        else :
            async = self.parameters['async']
            myparams['caltabold'] = caltabold = self.parameters['caltabold']
            myparams['vis'] = vis = self.parameters['vis']
            myparams['ptype'] = ptype = self.parameters['ptype']
            myparams['caltabnew'] = caltabnew = self.parameters['caltabnew']


        result = None

#
#    The following is work around to avoid a bug with current python translation
#
        mytmp = {}

        mytmp['caltabold'] = caltabold
        mytmp['vis'] = vis
        mytmp['ptype'] = ptype
        mytmp['caltabnew'] = caltabnew
        pathname='file:///'+os.environ.get('CASAPATH').split()[0]+'/share/xml/'
        trec = casac.casac.utils().torecord(pathname+'caltabconvert.xml')

        casalog.origin('caltabconvert')
        try :
          #if not trec.has_key('caltabconvert') or not casac.casac.utils().verify(mytmp, trec['caltabconvert']) :
            #return False

          casac.casac.utils().verify(mytmp, trec['caltabconvert'], True)
          scriptstr=['']
          saveinputs = self.__globals__['saveinputs']
          saveinputs('caltabconvert', 'caltabconvert.last', myparams, self.__globals__,scriptstr=scriptstr)
          if async :
            count = 0
            keybase =  time.strftime("%y%m%d.%H%M%S")
            key = keybase + "_" + str(count)
            while self.__async__.has_key(key) :
               count += 1
               key = keybase + "_" + str(count)
            result = tm.execute('caltabconvert', caltabold, vis, ptype, caltabnew)
            print "Use: "
            print "      tm.retrieve(return_value) # to retrieve the status"
            print 
            self.rkey = key
            self.__async__[key] = result
          else :
              tname = 'caltabconvert'
              spaces = ' '*(18-len(tname))
              casalog.post('\n##########################################'+
                           '\n##### Begin Task: ' + tname + spaces + ' #####')
              casalog.post(scriptstr[1][1:]+'\n', 'INFO')
              result = caltabconvert(caltabold, vis, ptype, caltabnew)
              casalog.post('##### End Task: ' + tname + '  ' + spaces + ' #####'+
                           '\n##########################################')

        except Exception, instance:
          if(self.__globals__.has_key('__rethrow_casa_exceptions') and self.__globals__['__rethrow_casa_exceptions']) :
             raise
          else :
             #print '**** Error **** ',instance
             tname = 'caltabconvert'
             casalog.post('An error occurred running task '+tname+'.', 'ERROR')
             pass

        gc.collect()
        return result
#
#
#
    def paramgui(self, useGlobals=True, ipython_globals=None):
        """
        Opens a parameter GUI for this task.  If useGlobals is true, then any relevant global parameter settings are used.
        """
        import paramgui
        if not hasattr(self, "__globals__") or self.__globals__ == None :
           self.__globals__=sys._getframe(len(inspect.stack())-1).f_globals

        if useGlobals:
            if ipython_globals == None:
                myf=self.__globals__
            else:
                myf=ipython_globals

            paramgui.setGlobals(myf)
        else:
            paramgui.setGlobals({})

        paramgui.runTask('caltabconvert', myf['_ip'])
        paramgui.setGlobals({})

#
#
#
    def defaults(self, param=None, ipython_globals=None, paramvalue=None, subparam=None):
        if not hasattr(self, "__globals__") or self.__globals__ == None :
           self.__globals__=sys._getframe(len(inspect.stack())-1).f_globals
        if ipython_globals == None:
            myf=self.__globals__
        else:
            myf=ipython_globals

        a = odict()
        a['caltabold']  = ''
        a['vis']  = ''
        a['ptype']  = 'complex'
        a['caltabnew']  = ''

        a['async']=False

### This function sets the default values but also will return the list of
### parameters or the default value of a given parameter
        if(param == None):
                myf['__set_default_parameters'](a)
        elif(param == 'paramkeys'):
                return a.keys()
        else:
            if(paramvalue==None and subparam==None):
               if(a.has_key(param)):
                  return a[param]
               else:
                  return self.itsdefault(param)
            else:
               retval=a[param]
               if(type(a[param])==dict):
                  for k in range(len(a[param])):
                     valornotval='value'
                     if(a[param][k].has_key('notvalue')):
                        valornotval='notvalue'
                     if((a[param][k][valornotval])==paramvalue):
                        retval=a[param][k].copy()
                        retval.pop(valornotval)
                        if(subparam != None):
                           if(retval.has_key(subparam)):
                              retval=retval[subparam]
                           else:
                              retval=self.itsdefault(subparam)
                     else:
                        retval=self.itsdefault(subparam)
               return retval


#
#
    def check_params(self, param=None, value=None, ipython_globals=None):
      if ipython_globals == None:
          myf=self.__globals__
      else:
          myf=ipython_globals
#      print 'param:', param, 'value:', value
      try :
         if str(type(value)) != "<type 'instance'>" :
            value0 = value
            value = myf['cu'].expandparam(param, value)
            matchtype = False
            if(type(value) == numpy.ndarray):
               if(type(value) == type(value0)):
                  myf[param] = value.tolist()
               else:
                  #print 'value:', value, 'value0:', value0
                  #print 'type(value):', type(value), 'type(value0):', type(value0)
                  myf[param] = value0
                  if type(value0) != list :
                     matchtype = True
            else :
               myf[param] = value
            value = myf['cu'].verifyparam({param:value})
            if matchtype:
               value = False
      except Exception, instance:
         #ignore the exception and just return it unchecked
         myf[param] = value
      return value
#
#
    def description(self, key='caltabconvert', subkey=None):
        desc={'caltabconvert': 'Convert old-style caltables into new-style caltables.\n',
               'caltabold': 'Name of the old-style caltable.',
               'vis': 'Name of the visibility file (MS) associated with the old-style caltable.',
               'ptype': 'Type of data in the new-format caltable ("complex" or "float"; default is "complex").',
               'caltabnew': 'Name of the new-style caltable.  If not specified, the suffix ".new" is appended to the name of old-style caltable.',

               'async': 'If true the taskname must be started using caltabconvert(...)'
              }

        if(desc.has_key(key)) :
           return desc[key]

    def itsdefault(self, paramname) :
        a = {}
        a['caltabold']  = ''
        a['vis']  = ''
        a['ptype']  = 'complex'
        a['caltabnew']  = ''

        #a = sys._getframe(len(inspect.stack())-1).f_globals

        if a.has_key(paramname) :
              return a[paramname]
caltabconvert_cli = caltabconvert_cli_()