simalma_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_simalma import simalma
class simalma_cli_:
    __name__ = "simalma"
    __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__ = (simalma_cli_,)
       self.__doc__ = self.__call__.__doc__

       self.parameters={'project':None, 'skymodel':None, 'inbright':None, 'indirection':None, 'incell':None, 'incenter':None, 'inwidth':None, 'complist':None, 'compwidth':None, 'setpointings':None, 'ptgfile':None, 'integration':None, 'direction':None, 'mapsize':None, 'antennalist':None, 'hourangle':None, 'totaltime':None, 'acaratio':None, 'acaconfig':None, 'pwv':None, 'image':None, 'imsize':None, 'imdirection':None, 'cell':None, 'niter':None, 'threshold':None, 'graphics':None, 'verbose':None, 'overwrite':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, project=None, skymodel=None, inbright=None, indirection=None, incell=None, incenter=None, inwidth=None, complist=None, compwidth=None, setpointings=None, ptgfile=None, integration=None, direction=None, mapsize=None, antennalist=None, hourangle=None, totaltime=None, acaratio=None, acaconfig=None, pwv=None, image=None, imsize=None, imdirection=None, cell=None, niter=None, threshold=None, graphics=None, verbose=None, overwrite=None,  async=None):

        """(Experimental) simple simulation task for ALMA 
ALMA simulation task:

    ##### WARNING: This task is EXPERIMENTAL #####
    This task simulates ALMA observation including 12-m, ACA 7-m and total
    power arrays, and images and analyzes simulated data.
    New functionality is actively being added, so if you have changed
    versions of CASA, check the inputs carefully.
    More information and examples are availible at 
     http://casaguides.nrao.edu/index.php?title=Simulating_Observations_in_CASA
    Please contact CASA experts with any questions, especially 
    about features noted below as *experimental*    
    -------------------------------
    project -- root filename for all output files.
    -------------------------------
    skymodel -- image model of the sky in FITS or CASA image, 
         with optional parameters that can be overridden
    inbright -- peak brightness in Jy/pixel, or "" for unchanged
       * NOTE: "unchanged" will take the numerical values in your image 
         and assume they are in Jy/pixel, even if it says some other unit 
         in the header. 
    indirection -- central direction, or "" for unchanged
    incell -- spatial pixel size, or "" for unchanged
    incenter -- frequency of center channel e.g. "89GHz", or "" for unchanged
    inwidth -- width of channels, or "" for unchanged - this should be a 
         string representing a quantity with units e.g. "10MHz"
       * NOTE: only works reliably with frequencies, not velocities
       * NOTE: it is not possible to change the number of spectral planes
         of the sky model, only to relabel them with different frequencies
         That kind of regridding can be accomplished with the CASA toolkit.
    -------------------------------
    complist -- component list model of the sky, added to or instead of skymodel
    compwidth -- bandwidth of components; if simulating from components only, 
         this defines the bandwidth of the MS and output images
    -------------------------------
    setpointings -- calculate a map of pointings, or if false, provide ptgfile
       * if graphics are on, display the pointings shown on the model image
    ptgfile -- a text file specifying directions in the same 
         format as the example, and optional integration times, e.g.
         #Epoch     RA          DEC      TIME(optional)
         J2000 23h59m28.10 -019d52m12.35 10.0
       * if the time column is not present in the file, it will use
         "integration" for all pointings.
       * NOTE: at this time the file should contain only science pointings:
         simalma will observe these until totaltime is used up. 
    integration --- Time interval for each integration e.g '10s'
       * NOTE: to simulate a "scan" longer than one integration, use 
         setpointings to generate a pointing file, and then edit the 
         file to increase the time at each point to be larger than 
         the parameter integration time.
    direction -- mosaic center direction e.g 'J2000 19h00m00 -40d00m00'
       * can optionally be a list of pointings
       * otherwise simalma will pack mapsize with grids proper for the
         array (see below).
    mapsize -- angular size of map 
       * set to "" to span the model image
    -------------------------------
    antennalist -- ascii file containing antenna positions.
       * NOTE: In this task, it should be an ALMA configuration.
       * standard arrays are found in your CASA data repository, 
         os.getenv("CASAPATH").split()[0]+"/data/alma/simmos/"        
       * a string of the form "alma;0.5arcsec" will be parsed into a full 12m ALMA
         configuration.  This only works for full ALMA and may fail to find the 
         standard configuration files on some systems - see casaguides.nrao.edu
    hourangle -- hour angle of observation e.g. '-3h'
    totaltime --- total time of observation e.g '7200s' or if a number without
         units, interpreted as the number of times to repeat the map
    acaratio  --- ratio of the total observation time of ACA relative to 
         that of 12m array. Set 0 for no ACA observation. 
         For Cycle-1, set acaratio = 0 or 3.
    acaconfig --- ACA configuration. Available configurations are:
       * "" (default) : automatically defines based on antennalist. 
               If antennalist is Cycle-1 configuration, acaconfig='cycle1'.
               Otherwise, acaconfig='i'
       * 'cycle1' : Cycle-1 ACA-7m configuration. Uses 'aca_cycle1.cfg'.
       * "i" : Normal ACA configuration in full operation. Uses 'aca.i.cfg'.
       * "ns": North-South extended configuration in full operation. 
               Uses 'aca.ns.cfg'.
    -------------------------------
    pwv -- precipitable water vapor if constructing an atmospheric model.
         Set 0 for noise-free simulation. When pwv > 0, thermal noise is
         applied to the simulated data.
       * J. Pardo's ATM library will be used to construct anatmospheric
         profile for the ALMA site:
         altitude 5000m, ground pressure 650mbar, relhum=20%, 
         a water layer of user_pwv at altitude of 2km,
         the sky brightness temperature returned by ATM, and internally
         tabulated receiver temperatures.
       See the documents of simobserve for more details.
    -------------------------------
    image -- invert and deconvolve the simulated measurement set(s)
       * NOTE: interactive clean or more parameters than the subset visible
         here are available by simply running the clean task directly.
       * NOTE: the channelization of the output image cube will be the 
         same as that in the simulated Measurement Set.
       * if graphics turned on, display the clean image and residual image
       * uses Cotton-Schwab clean for single fields and Mosaic gridding
         for multiple fields (with Clark PSF calculation in minor cycles).
    imsize -- image size in spatial pixels (x,y)
       0 or -1 will use the model image size; example: imsize=[500,500]
    imdirection -- phase center for synthesized image.  default is to 
       center on the sky model.
    cell -- cell size e.g '10arcsec'.  "" defaults to the skymodel cell
    niter -- number of clean/deconvolution iterations, 0 for no cleaning
    threshold -- flux level to stop cleaning
    -------------------------------
    graphics -- view plots on the screen, saved to file, both, or neither
    verbose -- print extra information to the logger and terminal
    overwrite -- overwrite existing files in the project subdirectory

    -------------------------------
    What does this task do:
    -------------------------------
    simalma is a task to simulate ALMA observation with simple interface. 
    It simulates ALMA 12m observation and optionally ACA 7m and Total power
    observations when acaratio > 0. 
    When image=True, simulated data are imaged and analyzed. CLEAN is used
    to generate image(s) from simulated data. ALMA 12m and ACA data are
    combined (if both geneareted) by taking ACA image as an initial model
    in CLEAN of ALMA 12m data.
    NOTE this task is very experimental and may not exactly reproduce
    actual ALMA products.

    The following assumptions are made to make the interface simple:
    * This task is intended to be run only once with a set of parameters.
      Therefore, it always sets up input model and pointings, and invokes simulation.
      You can stop before imaging step and reduce data manually with the other tasks,
      e.g, simanalyze, clean, and feather.
    * acaratio controls whether or not ACA observation is simulated. if acaratio > 0,
      ACA observation is simulated with total observation time = acaratio * totaltime
      for both ACA 7m and Total power array.
    * pwv controls whether or not thermal noise is applied to simulated data.
      When pwv > 0, the thermal noise is applied to simulated data. J. Pardo's ATM
      library is used to construct an atmospheric profile of the ALMA site.
    * if a list of directions is not specified, ALMA 12m and ACA 7m arrays will
      pack mapsize with the same hex algorithm as the ALMA OT in Nyquist sampling
    * Total power array maps slightly (+1 PB) larger area compared to 12m array for
      later combined imaging. It samples the region with lattice grids of spacing, 
      0.36 lamba/d.

    -------------------------------
    How to specify a model image:
    -------------------------------
    * simalma requires a CASA or fits image. If you merely have a grid of 
      numbers, you will need to write them out as fits or write a CASA script to
      read them in and use the ia tool to create an image and insert the data.
    
    * simalma does NOT require a coordinate system in the header. If the
      coordinate information is incomplete, missing, or you would like to
      override it, set the appropriate "in" paremeters.  
      In the absence of other information, simalma will assume that the axes of 
      your input correspond to RA, Dec, and (optionally) frequency and 
      (optionally) Stokes parameter.  

    * If you have a proper Coordinate System, simalma will do its best to
      generate visibilities from that, and then create a synthesis image
      according to the specified user parameters.  Regridding the
      spectral dimension may not have complete flexibility yet.

    * You can manipulate an image header with the "imhead" task.


    Please see the documents of simobserve and simanalyze for
    the list of outputs produced.


        """
        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'] = 'simalma'
        self.__globals__['taskname'] = 'simalma'
        ###
        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['project'] = project = self.parameters['project']
            myparams['skymodel'] = skymodel = self.parameters['skymodel']
            myparams['inbright'] = inbright = self.parameters['inbright']
            myparams['indirection'] = indirection = self.parameters['indirection']
            myparams['incell'] = incell = self.parameters['incell']
            myparams['incenter'] = incenter = self.parameters['incenter']
            myparams['inwidth'] = inwidth = self.parameters['inwidth']
            myparams['complist'] = complist = self.parameters['complist']
            myparams['compwidth'] = compwidth = self.parameters['compwidth']
            myparams['setpointings'] = setpointings = self.parameters['setpointings']
            myparams['ptgfile'] = ptgfile = self.parameters['ptgfile']
            myparams['integration'] = integration = self.parameters['integration']
            myparams['direction'] = direction = self.parameters['direction']
            myparams['mapsize'] = mapsize = self.parameters['mapsize']
            myparams['antennalist'] = antennalist = self.parameters['antennalist']
            myparams['hourangle'] = hourangle = self.parameters['hourangle']
            myparams['totaltime'] = totaltime = self.parameters['totaltime']
            myparams['acaratio'] = acaratio = self.parameters['acaratio']
            myparams['acaconfig'] = acaconfig = self.parameters['acaconfig']
            myparams['pwv'] = pwv = self.parameters['pwv']
            myparams['image'] = image = self.parameters['image']
            myparams['imsize'] = imsize = self.parameters['imsize']
            myparams['imdirection'] = imdirection = self.parameters['imdirection']
            myparams['cell'] = cell = self.parameters['cell']
            myparams['niter'] = niter = self.parameters['niter']
            myparams['threshold'] = threshold = self.parameters['threshold']
            myparams['graphics'] = graphics = self.parameters['graphics']
            myparams['verbose'] = verbose = self.parameters['verbose']
            myparams['overwrite'] = overwrite = self.parameters['overwrite']

        if type(direction)==str: direction=[direction]
        if type(mapsize)==str: mapsize=[mapsize]
        if type(imsize)==int: imsize=[imsize]

        result = None

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

        mytmp['project'] = project
        mytmp['skymodel'] = skymodel
        mytmp['inbright'] = inbright
        mytmp['indirection'] = indirection
        mytmp['incell'] = incell
        mytmp['incenter'] = incenter
        mytmp['inwidth'] = inwidth
        mytmp['complist'] = complist
        mytmp['compwidth'] = compwidth
        mytmp['setpointings'] = setpointings
        mytmp['ptgfile'] = ptgfile
        mytmp['integration'] = integration
        mytmp['direction'] = direction
        mytmp['mapsize'] = mapsize
        mytmp['antennalist'] = antennalist
        mytmp['hourangle'] = hourangle
        mytmp['totaltime'] = totaltime
        mytmp['acaratio'] = acaratio
        mytmp['acaconfig'] = acaconfig
        mytmp['pwv'] = pwv
        mytmp['image'] = image
        mytmp['imsize'] = imsize
        mytmp['imdirection'] = imdirection
        mytmp['cell'] = cell
        mytmp['niter'] = niter
        mytmp['threshold'] = threshold
        mytmp['graphics'] = graphics
        mytmp['verbose'] = verbose
        mytmp['overwrite'] = overwrite
        pathname='file:///'+os.environ.get('CASAPATH').split()[0]+'/share/xml/'
        trec = casac.casac.utils().torecord(pathname+'simalma.xml')

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

          casac.casac.utils().verify(mytmp, trec['simalma'], True)
          scriptstr=['']
          saveinputs = self.__globals__['saveinputs']
          saveinputs('simalma', 'simalma.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('simalma', project, skymodel, inbright, indirection, incell, incenter, inwidth, complist, compwidth, setpointings, ptgfile, integration, direction, mapsize, antennalist, hourangle, totaltime, acaratio, acaconfig, pwv, image, imsize, imdirection, cell, niter, threshold, graphics, verbose, overwrite)
            print "Use: "
            print "      tm.retrieve(return_value) # to retrieve the status"
            print 
            self.rkey = key
            self.__async__[key] = result
          else :
              tname = 'simalma'
              spaces = ' '*(18-len(tname))
              casalog.post('\n##########################################'+
                           '\n##### Begin Task: ' + tname + spaces + ' #####')
              casalog.post(scriptstr[1][1:]+'\n', 'INFO')
              result = simalma(project, skymodel, inbright, indirection, incell, incenter, inwidth, complist, compwidth, setpointings, ptgfile, integration, direction, mapsize, antennalist, hourangle, totaltime, acaratio, acaconfig, pwv, image, imsize, imdirection, cell, niter, threshold, graphics, verbose, overwrite)
              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 = 'simalma'
             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('simalma', 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['project']  = 'sim'
        a['skymodel']  = ''
        a['complist']  = ''
        a['setpointings']  = True
        a['antennalist']  = 'alma_cycle1_1.cfg'
        a['hourangle']  = 'transit'
        a['totaltime']  = '7200s'
        a['acaratio']  = 0.0
        a['pwv']  = 0.0
        a['image']  = True
        a['graphics']  = 'both'
        a['verbose']  = False
        a['overwrite']  = False

        a['async']=False
        a['skymodel'] = {
                    0:odict([{'notvalue':''}, {'inbright':''}, {'indirection':''}, {'incell':''}, {'incenter':''}, {'inwidth':''}])}
        a['complist'] = {
                    0:odict([{'notvalue':''}, {'compwidth':'8GHz'}])}
        a['setpointings'] = {
                    0:odict([{'value':True}, {'integration':'10s'}, {'direction':''}, {'mapsize':['', '']}]), 
                    1:odict([{'value':False}, {'ptgfile':'$project.ptg.txt'}, {'integration':'10s'}])}
        a['acaratio'] = {
                    0:odict([{'notvalue':0}, {'acaconfig':''}])}
        a['image'] = {
                    0:odict([{'value':True}, {'imsize':0}, {'imdirection':''}, {'cell':''}, {'niter':500}, {'threshold':'0.1mJy'}]), 
                    1:{'value':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='simalma', subkey=None):
        desc={'simalma': '(Experimental) simple simulation task for ALMA ',
               'project': 'root prefix for output file names',
               'skymodel': 'model image to observe',
               'inbright': 'scale surface brightness of brightest pixel e.g. "1.2Jy/pixel"',
               'indirection': 'set new direction e.g. "J2000 19h00m00 -40d00m00"',
               'incell': 'set new cell/pixel size e.g. "0.1arcsec"',
               'incenter': 'set new frequency of center channel e.g. "89GHz" (required even for 2D model)',
               'inwidth': 'set new channel width e.g. "10MHz" (required even for 2D model)',
               'complist': 'componentlist to observe',
               'compwidth': 'bandwidth of components',
               'setpointings': '',
               'ptgfile': 'list of pointing positions',
               'integration': 'integration (sampling) time',
               'direction': '"J2000 19h00m00 -40d00m00" or "" to center on model',
               'mapsize': 'angular size of map or "" to cover model',
               'antennalist': 'antenna position file of ALMA 12m array',
               'hourangle': 'hour angle of observation center e.g. -3:00:00, or "transit"',
               'totaltime': 'total time of observation or number of repetitions',
               'acaratio': 'Ratio of the total observation time for ACA in relation to 12-m array or 0 for no ACA',
               'acaconfig': 'Antenna configuration of ACA 7-m array [""|"cycle1"|"i"|"ns"]',
               'pwv': 'Precipitable Water Vapor in mm. 0 for noise-free simulation',
               'image': 'image simulated data',
               'imsize': 'output image size in pixels (x,y) or 0 to match model',
               'imdirection': 'set output image direction, (otherwise center on the model)',
               'cell': 'cell size with units or "" to equal model',
               'niter': 'maximum number of iterations (0 for dirty image)',
               'threshold': 'flux level (+units) to stop cleaning',
               'graphics': 'display graphics at each stage to [screen|file|both|none]',
               'verbose': '',
               'overwrite': 'overwrite files starting with $project',

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

#
# Set subfields defaults if needed
#
        if(subkey == 'True'):
          desc['direction'] = 'center of map or "" to center on the model'
        if(subkey == 'False'):
          desc['integration'] = 'integration time (see below)'

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

    def itsdefault(self, paramname) :
        a = {}
        a['project']  = 'sim'
        a['skymodel']  = ''
        a['inbright']  = ''
        a['indirection']  = ''
        a['incell']  = ''
        a['incenter']  = ''
        a['inwidth']  = ''
        a['complist']  = ''
        a['compwidth']  = '"8GHz"'
        a['setpointings']  = True
        a['ptgfile']  = '$project.ptg.txt'
        a['integration']  = '10s'
        a['direction']  = ['']
        a['mapsize']  = ['', '']
        a['antennalist']  = 'alma_cycle1_1.cfg'
        a['hourangle']  = 'transit'
        a['totaltime']  = '7200s'
        a['acaratio']  = 0.0
        a['acaconfig']  = ''
        a['pwv']  = 0.0
        a['image']  = True
        a['imsize']  = [128, 128]
        a['imdirection']  = ''
        a['cell']  = ''
        a['niter']  = 500
        a['threshold']  = '0.1mJy'
        a['graphics']  = 'both'
        a['verbose']  = False
        a['overwrite']  = False

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

        if self.parameters['skymodel']  != '':
            a['inbright'] = ''
            a['indirection'] = ''
            a['incell'] = ''
            a['incenter'] = ''
            a['inwidth'] = ''

        if self.parameters['complist']  != '':
            a['compwidth'] = '8GHz'

        if self.parameters['setpointings']  == True:
            a['integration'] = '10s'
            a['direction'] = ''
            a['mapsize'] = ['', '']

        if self.parameters['setpointings']  == False:
            a['ptgfile'] = '$project.ptg.txt'
            a['integration'] = '10s'

        if self.parameters['acaratio']  != 0:
            a['acaconfig'] = ''

        if self.parameters['image']  == True:
            a['imsize'] = 0
            a['imdirection'] = ''
            a['cell'] = ''
            a['niter'] = 500
            a['threshold'] = '0.1mJy'

        if a.has_key(paramname) :
              return a[paramname]
simalma_cli = simalma_cli_()