# Cormac Reynolds (reynolds@jive.nl): Jan 2006 original version
# a whole bunch of shortcut functions for executing AIPS tasks with most
# parameters defaulted to sensible values for the EVN. Used by EVN.py
from AIPS import AIPS, AIPSDisk
from AIPSTask import AIPSTask, AIPSList
from AIPSData import AIPSUVData, AIPSImage, AIPSCat
from AIPSTV import AIPSTV
#import Wizardry.AIPSData

import LocalProxy
from xmlrpclib import ServerProxy

import copy, optparse, os, sys
import re, string, numarray, numarray.mlab, pprint, math

#AIPS.log = open(os.getcwd() + 'AIPS.LOG', 'w')
#AIPSTask.isbatch = 0
AIPSTask.version = '31DEC07' # May be overwritten by input file

task_versions = {} # Will be populated when input file is read

def versioned_task(taskname):
    if taskname in task_versions:
        return AIPSTask(taskname, version=task_versions[taskname])
    else:
        return AIPSTask(taskname)

FuncLog = sys.stdout
my_tv = AIPSTV()

def runclcal(snver, indata, refant, gainver=0, gainuse=0, opcode='CALI',
        interpol='2PT', calsour=[], sources=[], samptype='',
        doblank=0, dobtween=0):
    # function to run clcal. Don't allow default snver.
    """Must set snver, refant, indata"""

    #assert (snver != None, refant != None, indata != None), """missing snver,
    #        refant or indata in runclcal""" 
    clcal = versioned_task('clcal')
    clcal.indata = indata
    clcal.subarray = 1
    clcal.calsour[1:] = calsour
    clcal.sources[1:] = sources
    clcal.opcode = opcode
    clcal.interpol = interpol
    #clcal.intparm = 0.00001
    clcal.samptype = samptype
    clcal.doblank = doblank
    clcal.dobtween = dobtween
    clcal.refant = refant
    clcal.snver = snver
    clcal.gainver = gainver
    clcal.gainuse = gainuse
    clcal()

def runindxr(indata):
    indxr = versioned_task('indxr')
    indxr.indata = indata
    indxr.cparm[1:] = [0, 22, .25]
    indxr()

def runpossm(indata, aparm, solint=-1, freqid=1, sources=[],
        timerang=[0,0,0,1], codetype='A&P',
        nplots=9, stokes='HALF', antennas=[], docalib=0, gainuse=0,
        doband=0, bpver=0, flagver=1, dotv=-1):

    """Must set indata, aparm"""

    #assert (aparm != None, indata != None), "set indata, aparm in runpossm!"

    #print 'possm antennas=', antennas
    #raw_input('press return')

    possm = versioned_task('possm')

    possm.stokes = stokes
    possm.indata = indata
    possm.solint = solint
    possm.freqid = freqid
    possm.sources[1:] = sources
    possm.timerang[1:] = timerang
    possm.antennas[1:] = antennas
    possm.docalib = docalib
    possm.gainuse = gainuse
    possm.flagver = flagver
    possm.doband = doband
    possm.bpver = bpver
    possm.aparm[1:] = aparm[1:]
    possm.codetype = codetype
    possm.nplots = nplots
    possm.dotv = dotv
    possm()

def runvplot(indata, bparm, antenna=[], in2data=None, freqid=1, bchan=1, 
        echan=4096, bif=1, eif=0, sources=[], docalib=1, gainuse=0, flagver=0,
        doband=-1, bpver=0, solint=0, nplots=4, ncomp=0, nmaps=0, stokes='',
        dotv=-1):

    """Must set indata, bparm"""
    #assert (indata != None, bparm != None  and antenna !=
    #        None), """bparms or antenna not set in runvplot!"""

    vplot = versioned_task('vplot')
    vplot.indata = indata
    if is_aipsdata(in2data):
        vplot.in2data = in2data
    vplot.ncomp[1] = ncomp
    vplot.nmaps = nmaps
    vplot.sources[1:] = sources
    vplot.freqid = freqid 
    vplot.bchan = bchan
    vplot.echan = echan 
    vplot.bif = bif
    vplot.eif = eif 
    vplot.stokes = stokes
    vplot.antenna[1:] = antenna
    vplot.docalib = docalib
    vplot.gainuse = gainuse
    vplot.flagver = flagver
    vplot.doband = doband
    vplot.doebar = -1
    vplot.solint = solint 
    vplot.bparm[1:] = bparm[1:]
    vplot.nplots = nplots 
    vplot.ltype = 3 
    vplot.dotv = dotv
    vplot.grchan = 1
    error = 0
    try:
        vplot()
        error = 0
    except:
        error = 1
    return error

def runfring(indata, snver, solint, aparm, dparm, refantlist,  freqid=1, 
        gainuse=0, flagver=1, calsour=[], snr=9):

    """Must set indata, snver, solint, refantlist, aparm, dparm"""
    #assert (indata != None, snver != None, solint != None, refantlist != None,
    #        aparm != None, dparm != None), """must set indata, snver, solint
    #        and refantlist for runfring"""

    fring = versioned_task('fring')

    # calsour has limit of 30 sources. Split calsour into groups of
    # max. 30 and fring each group separately
    bsource = -1
    esource = -1
    while bsource == -1 or esource < len(calsour)-1:
        bsource = esource+1
        esource = split_list(calsour, bsource, len(fring.calsour)-1)
        print >>FuncLog, 'Fringing sources ', str(bsource+1), ' to ', str(esource+1)

        fring.indata = indata
        fring.outdata = indata
        fring.freqid = freqid
        fring.gainuse = gainuse
        fring.flagver = flagver
        fring.docalib = 2
        fring.subarray = 1
        fring.refant = refantlist[0]
        fring.search[1:] = refantlist[1:]
        fring.snver = snver
        fring.solint = solint
        fring.calsour[1:] = calsour[bsource:esource+1]
        fring.aparm[1:] = aparm[1:]
        fring.aparm[7] = snr
        fring.dparm[1:] = dparm[1:]
        fring()

def runantab(antab_file, indata, tyver=1, gcver=1, offset=0.3, sparm=[]):

    """Must set indata, antab_file"""
    #assert (antab_file != None, indata != None), '''set antab_file, indata in
    #        runantab'''
    antab = versioned_task('antab')
    try:
        antab.calin = antab_file
    except AttributeError:
        antab.infile = antab_file
    antab.indata = indata
    antab.tyver = tyver
    antab.gcver = gcver
    antab.offset = 0.3
    antab.sparm[1:] = sparm
    antab()

def runavspc(indata, outdata, nchan, flagver=0, channel=0):

    """Must set indata, outdata, nchan"""
    #assert (indata != None, outdata != None, nchan != None), """set indata,
    #        outdata, nchan in runavspc!"""
    avspc = versioned_task('avspc')
    avspc.indata = indata
    avspc.outdata = outdata
    avspc.ichansel[1:][1:] = [[1, nchan, 1]]
    avspc.avoption = 'SUBS'
    #avspc.bif = 1
    #avspc.eif = 0
    avspc.flagver = flagver
    avspc.channel = channel
    avspc()

def runtacop(indata, outdata, inext, inver=0, outver=0):

    """Must set indata, outdata, inext"""
    #assert (indata != None, outdata != None, inext != None), """set indata,
    #            outdata, inext in runtacop"""

    tacop = versioned_task ('tacop')
    tacop.indata = indata
    tacop.outdata = outdata
    tacop.keyword = ''
    tacop.keyval  = 0
    tacop.keystr = ''
    tacop.inext = inext
    tacop.inver = inver
    tacop.outver = outver
    tacop.ncount = 1
    tacop()

def runfitld(outdata, infile, nfits=0):

    """Must set outdata, infile"""
    #assert (outdata != None, infile != None), "set indata, infile in runfitld" 
    fitld = versioned_task('fitld')
    fitld.outdata = outdata
    fitld.ncount = nfits
    fitld.douvcomp = 1
    fitld.doconcat = 1
    fitld.clint = .25
    try:
        fitld.datain = infile
    except AttributeError:
        fitld.infile = infile
    # trick to ignore data with '0' time
    fitld.timerang[1:] = [0, 0, 1, 0, 10, 0, 0, 0]
    #print "fits file = " + fitld.infile
    fitld()

def runbpass(refant, indata, calsour):

    """Must set refant, calsour, indata"""
    #assert (refant != None, calsour != None, indata != None), '''set
    #        refantlist in runbpass'''

    bpass = versioned_task('bpass')
    bpass.indata = indata
    bpass.calsour[1:] = calsour
    bpass.freqid = 1
    bpass.bif = 1
    bpass.eif = 0
    bpass.flagver= 1
    bpass.subarray = 1
    bpass.docalib = 2
    bpass.gainuse = 3
    bpass.solint = -1
    bpass.refant = refant
    bpass.soltype = 'L1'
    bpass.bpver = 1
    bpass.smooth[1] = 1
    #bpass.bpassprm[5] = 1
    #bpass.bpassprm[9] = 1
    bpass()

def runsplit(indata, sources=[], gainuse=0, doband=0, bpver=0, outseq=0,
        docalib=2):

    """Must set indata"""
    #assert (indata != None)
    split = versioned_task('split')

    # 'sources' has limit of 30 sources. Split into groups of
    # max. 30 and split each group separately
    bsource = -1
    esource = -1
    while bsource == -1 or esource < len(sources)-1:
        bsource = esource+1
        esource = split_list(sources, bsource, len(split.sources)-1)
        print >>FuncLog, 'Splitting sources ', str(bsource+1), ' to ', str(esource+1)

        split.indata = indata
        split.outclass = 'SPLIT'
        split.outdisk = indata.disk
        split.outseq = outseq
        split.subarray = 1
        split.sources[1:] = sources[bsource:esource+1]
        split.docalib = docalib
        split.gainuse = gainuse
        split.doband = doband
        split.aparm[1] = 2
        split.aparm[4] = 1
        split()

def runmulti(indata, outdata):

    """Must set indata, outdata"""
    #assert(indata != None, outdata != None)
    multi = versioned_task('multi')
    multi.indata = indata
    multi.outdata = outdata
    multi.source[1] = indata.name
    multi.aparm[1] = 0.067
    multi()

def runimagr(indata, cellsize, source, outdata=None, stokes='I', docalib=2, 
        uvwtfn='U', imsize=512, niter=100, freqid=1, nchan=0, dotv=-1,
        robust=0, flagver=0, dopol=-1, ccmin=-0.1e-4):

    """ must set indata, cellsize and source"""
    #assert (indata != None, cellsize != None and source != None), '''cellsize
    #        not set in runimagr'''

    if dotv > 0:
        my_tv.clear()

    imagr = versioned_task('imagr')
    imagr.isbatch = 0
    imagr.indata = indata
    if (outdata != None):
        imagr.outname = outdata.name
        imagr.outdisk = outdata.disk
        imagr.outseq = outdata.seq
    imagr.sources[1] = source
    imagr.freqid = freqid
    imagr.subarray = 1
    imagr.docalib = docalib
    imagr.dopol = dopol
    imagr.nchav = nchan
    imagr.chinc = nchan
    imagr.flagver = flagver
    imagr.stokes = stokes
    imagr.uvwtfn = uvwtfn
    imagr.cellsize[1:] = [cellsize, cellsize]
    imagr.imsize[1:] = [imsize, imsize]
    imagr.robust = robust
    imagr.xtype = 5
    imagr.ytype = 5
    imagr.niter = niter
    imagr.allokay = -1
    imagr.gain = 0.05
    imagr.minpatch = imsize // 2
    imagr.imagrprm[8:10] = [ccmin, 1]
    imagr.dotv = dotv
    #imagr.maxpix = 0
    #imagr.inp()
    imagr()

def jimagr(uvdata, cellsize, out_data, clbox, imsize=512, sources_use='',
        docalib=2, niter=1000, timerange=[0,0,0,0], flagver=0,
        bpver=0, stokes='I', flux=0, dotv=0, robust_use=0,
        gainuse=0):


        print 'trying to IMAGR', sources_use, 'with robust', robust_use
        print 'using dataset', uvdata
        imagr = versioned_task('imagr')
        imagr.indata = uvdata
        imagr.outname = out_data.name
        imagr.outseq = out_data.seq
        imagr.outdisk = out_data.disk
        if(type(sources_use) == type('string')):
            imagr.sources[1] = sources_use
        else:
            imagr.sources[1:] = sources_use
        if(timerange != None):
            if(timerange[0] == None): imagr.timerang = timerange
            else: imagr.timerang[1:] = timerange
        imagr.freqid = 1
        imagr.docalib = docalib
        imagr.gainuse = gainuse
        imagr.flagver=flagver
        if(bpver > 0):
            imagr.doband = 3
            imagr.bpver = bpver
        imagr.nchav = uvdata.header['naxis'][2]
        #imagr.chinc = 1
        imagr.stokes = stokes
        imagr.uvwtfn = 'U'
        imagr.robust = robust_use
        imagr.cellsize[1:] = [cellsize, cellsize]
        imagr.imsize[1:] = [imsize, imsize]
        imagr.nfield=0
        imagr.xtype = 5
        imagr.ytype = 5
        imagr.niter = niter
        imagr.gain = 0.03
        imagr.flux=flux
        if(clbox != None):
            imagr.nboxes = 1
            if(clbox[0] != None): imagr.clbox[1] = AIPSList(clbox)
            else: imagr.clbox[1] = clbox
        imagr.overlap=1
        imagr.minpatch = max(imsize / 3,101)
        #imagr.imagrprm[8] = -0.1e-4
        imagr.dotv = dotv
        #if(imagr.dotv > 0):
        #    tv_local.clear()
        retval = imagr()

def runcalib(indata, solint, calsour, solmode, refant, in2data='', docalib=2, 
        gainuse=0, flagver=0, ncomp=0, soltype='L1', snr=5, freqid=1, doband=0,
        bpver=0, modelflux=0, snver=0):

    '''Must set solint, solmode, calsour, refant'''
    #assert (indata != None, solint != None, calsour != None, solmode != None,
    #        refant != None), '''Set solint, solmode and calsour in runcalib!'''

    calib = versioned_task('calib')
    calib.indata = indata
    if is_aipsdata(in2data):
        calib.in2data = in2data
    calib.calsour[1] = calsour
    calib.freqid = freqid
    calib.docalib = docalib
    calib.gainuse = gainuse
    calib.flagver = flagver
    calib.doband = doband
    calib.bpver = bpver
    calib.ncomp[1] = ncomp
    calib.smodel[1] = modelflux
    solmode = solmode.upper()
    if (solmode == 'P'):
        calib.aparm[1] = 3
    else:
        calib.aparm[1] = 4
    calib.aparm[6] = 3
    calib.aparm[7] = snr
    calib.solint = solint
    calib.refant = refant
    calib.soltype = soltype
    calib.solmode = solmode
    calib.minamper = 10
    calib.minphser = 20
    calib.cparm[1] = 10
    calib.cparm[3] = 10
    calib.cparm[4] = 20
    calib.snver = snver
    #calib.inp()
    calib()

def runsnsmo(indata, refant, invers=0, source=[], smotype='AMPL', smotime=10,
        dobtween=0, samptype='MWF'):

    """Must set indata, refant"""
    #assert (indata != None, refant != None)
    snsmo = versioned_task('snsmo')

    snsmo.indata = indata
    snsmo.source = source
    snsmo.dobtween = dobtween
    snsmo.freqid = 1
    snsmo.bif = 1
    snsmo.eif = 0
    snsmo.samptype = samptype
    snsmo.doblank = -1
    snsmo.smotype = smotype
    snsmo.cparm[1] = smotime
    snsmo.cparm[2] = smotime
    snsmo.cparm[6] = 2
    snsmo.invers = invers
    snsmo.outvers = invers
    snsmo.refant = refant
    snsmo()

def runlistr(indata, outprint, optype='', inver=0, freqid=1,
        docalib=0, inext='SN', stokes='HALF', sources=[], dparm=[]):

    """Must set indata, outprint"""
    #assert (indata != None, outprint != None)

    listr = versioned_task('listr')
    listr.indata = indata
    listr.outprint = outprint
    listr.optype = optype
    listr.inext = inext
    listr.inver = inver
    listr.stokes = stokes
    listr.freqid = freqid
    listr.sources[1:] = sources
    listr.bif = 0
    listr.eif = 0
    listr.bchan = 1
    listr.echan = 0
    listr.docalib = docalib
    listr.gainuse = 0
    listr.flagver = 0
    listr.dparm[1:] = dparm[1:]
    listr.dparm[3] = 6
    listr.docrt = -1
    listr()

def runuvplt(indata, bparm, freqid=1, docalib=2, gainuse=0, sources=[], 
        dotv=-1, antennas=[], baseline=[], grchan=0, bchan=1, echan=0, refant=0):

    """Must set indata, bparm"""
    #assert (indata != None, bparm != None), 'set indata, bparm in runuvplt'

    uvplt = versioned_task('uvplt')
    uvplt.indata = indata
    uvplt.sources[1:] = sources
    uvplt.qual = -1
    uvplt.calcod = ''
    uvplt.stokes = 'I'
    uvplt.selband = -1
    uvplt.selfreq = -1
    uvplt.freqid = freqid
    uvplt.timerang[1:] = [0]
    uvplt.anten[1:] = antennas
    uvplt.basel[1:] = baseline
    uvplt.uvrange[1:] = [0]
    uvplt.subarray = 0
    uvplt.bchan = bchan
    uvplt.echan = echan
    uvplt.chinc = 1
    uvplt.bif = 1
    uvplt.eif = 0
    uvplt.docalib = docalib
    uvplt.gainuse = gainuse
    uvplt.dopol = -1
    uvplt.blver = -1
    uvplt.flagver = 0
    uvplt.doband = -1
    uvplt.bpver = 0
    uvplt.smooth[1:] = [0]
    uvplt.xinc = 1
    uvplt.bparm[1:] = bparm[1:]
    uvplt.doweight = 1
    uvplt.refant = refant
    uvplt.rotate = 0
    uvplt.factor = 0
    uvplt.ltype = 3
    uvplt.dotv = dotv
    uvplt.grchan = grchan

    uvplt()

def runuvsub(indata, in2data, opcode='DIV'):
    """Must set indata, in2data"""

    #assert (indata != None, in2data != None)
    uvsub = versioned_task('uvsub')
    uvsub.indata = indata
    uvsub.nmaps = 1
    uvsub.channel = 0
    uvsub.bif = 1
    uvsub.eif = 0
    if is_aipsdata(in2data):
        uvsub.in2data = in2data
    uvsub.inver = 0
    uvsub.outdisk = indata.disk
    uvsub.bcomp[1:] = [0]
    uvsub.ncomp[1] = 0
    uvsub.flux = 0
    uvsub.cmethod = ''
    uvsub.cmodel = ''
    uvsub.factor = 0
    uvsub.opcode = opcode
    uvsub.smodel[1:] = [0]
    uvsub()

def runclplt(indata, freqid=1, nif=0):
    """Must set indata"""

    #assert (indata != None)
    clplt = versioned_task('clplt')
    clplt.userid = 0
    clplt.indata = indata
    clplt.ncomp[1] = 0
    clplt.flux = 0
    clplt.nmaps = 0
    clplt.sources[1:] = ['']
    clplt.qual = -1
    clplt.calcode = ''
    clplt.selband = -1
    clplt.selfreq = -1
    clplt.freqid = freqid
    clplt.bchan = 1
    clplt.echan = 2048
    clplt.bif = 1
    clplt.eif = nif
    clplt.xinc = 1
    clplt.uvrange[1:] = [0]
    clplt.timer[1:] = [0]
    clplt.docalib = 0
    clplt.gainuse = 0
    clplt.dopol = -1
    clplt.blver = -1
    clplt.flagver = 0
    clplt.doband = -1
    clplt.bpver = 0
    clplt.smooth[1:] = [0]
    clplt.suba = 1
    clplt.doebar = -1
    clplt.solint = 20./60.
    clplt.opcode = ''
    clplt.phslimit = 0
    clplt.bparm[8] = 5
    clplt.polplot = ''
    clplt.symbol = 0
    clplt.ltype = 4
    clplt.dotv = -1
    clplt.grchan = 1
    clplt()


def runtasav(indata, outdata):

    """Must set indata, outdata"""
    #assert (indata != None, outdata != None)
    tasav = versioned_task('tasav')
    tasav.indata = indata
    tasav.outdata = outdata
    tasav()

def runtacop(indata, outdata, inext, inver=0, outver=0, ncount=1):

    """Must set indata, outdata, inext"""
    #assert (inext != None, indata != None, outdata != None), '''set inext in 
    #        runtacop'''

    tacop  =  versioned_task('tacop')
    tacop.indata = indata
    tacop.outdata = outdata
    tacop.keyword = ''
    tacop.keyval[1:] = [0]
    tacop.keystr = ''
    tacop.inext = inext
    tacop.inver = inver
    tacop.outver = outver
    tacop.ncount = ncount
    tacop()

def runfittp(indata, outfile):

    """Must set indata, outfile"""
    #assert (outfile != None), 'set outfile in runfittp'

    fittp = versioned_task ('fittp')
    fittp.indata = indata
    fittp.doall = -1
    fittp.intype = ''
    fittp.outtape = 1
    try:
        fittp.dataout = outfile
    except AttributeError:
        fittp.outfile = outfile
    fittp()

def runuvprm(indata, flagver=0, channel=0, bif=0, docalib=1):

    """Must set indata"""
    #assert (indata != None)
    uvprm = versioned_task('uvprm')
    uvprm.indata = indata
    uvprm.docalib = docalib
    uvprm.stokes = 'I'
    uvprm.flagver = flagver
    uvprm.channel = channel
    uvprm.bif = bif
    uvprm()

def runcoher(indata, bif=0, sources=[], freqid=1):

    '''Must set indata'''
    #assert (indata != None)
    coher = versioned_task('coher')
    coher.indata = indata
    coher.aparm[6] = 1
    coher.bif = bif
    coher.sources[1:] = sources
    coher.freqid = freqid
    coher()

def runuvflg(indata, sources=[], freqid=1, bchan=0, echan=0, bif=0, eif=0,
            antennas=[], flagver=1, opcode='FLAG', reason='uvflg', infile=''):

    '''Must set indata'''
    #assert (indata != None)
    uvflg = versioned_task('uvflg')
    uvflg.indata = indata
    try:
        uvflg.intext = infile
    except AttributeError:
        uvflg.infile = infile
    uvflg.sources[1:] = sources
    uvflg.freqid = freqid
    uvflg.bchan = bchan
    uvflg.echan = echan
    uvflg.bif = bif
    uvflg.eif = eif
    uvflg.antennas[1:] = antennas
    # flagver changed to outfgver in 31DEC07:
    if hasattr(uvflg, 'outfgver'):
        uvflg.outfgver = flagver
    else:
        uvflg.flagver = flagver
    uvflg.opcode = opcode
    uvflg.reason = reason
    uvflg()

def runsnplt(indata, inext='SN', invers=0, optype='PHAS', dotv=-1, antennas=[],
            bif=0, eif=0, sources=[]):

    '''Must set indata'''
    #assert(indata != None)
    if dotv > 0:
        my_tv.clear()

    snplt = versioned_task('snplt')
    snplt.indata = indata
    snplt.inext = inext
    snplt.invers = invers
    snplt.optype = optype
    snplt.antennas[1:] = antennas
    snplt.sources[1:] = sources
    snplt.bif = bif
    snplt.eif = eif
    snplt.nplots = 10
    snplt.factor = 0.5
    #snplt.doebar = -1.
    snplt.cutoff = 1e-6
    snplt.dotv = dotv
    try:
        snplt()
        error = 0
    except:
        error = 1

    return error


def runlwpla(indata, outfile, inver=None, plver=1):

    '''Must set indata, outfile'''
    #assert (indata != None, outfile != None)

    lwpla = versioned_task('lwpla')
    lwpla.indata = indata
    lwpla.outfile = outfile 
    lwpla.lpen = 1.
    lwpla.dparm[6] = 4
    lwpla.dparm[8] = 9
    lwpla.plver = plver
    if (inver == None):
        inver = indata.table_highver('AIPS PL')
    lwpla.inver = inver
    lwpla()



def runimean(indata, blc=0, trc=0):
    '''Must set indata'''

    #assert (indata != None)
    imean = versioned_task('imean')
    imean.indata = indata
    imean.blc[1:] = blc
    imean.trc[1:] = trc
    imean()
    datamax = indata.header.datamax
    return (datamax, imean.pixstd)


def runkntr(indata, rmsflux, peakflux, in2data=None, in3data=None,
        in4data=None, blc=0, trc=0, dotv=-1, dovect=0):

    '''Must set indata, rmsflux, peakflux'''
    #assert(indata!=None, rmsflux!=None, peakflux != None)

    if dotv > 0:
        my_tv.clear()

    kntr = versioned_task('kntr')
    kntr.indata = indata
    if is_aipsdata(in2data):
        kntr.in2data = in2data
    if is_aipsdata(in3data):
        kntr.in3data = in3data
    if is_aipsdata(in4data):
        kntr.in4data = in4data
    kntr.dovect = dovect
    kntr.dogrey = 0
    kntr.ltype = 4
    kntr.darkline = 0
    kntr.blc[1:] = [blc, blc]
    kntr.trc[1:] = [trc, trc]
    kntr.plev = 1
    kntr.xinc = 2
    kntr.yinc = 2
    # longest P vector should be a decent number of pixels long.
    kntr.factor = 20./peakflux 
    # make pcut a few times the bottom contour
    kntr.icut = 0
    kntr.pcut = rmsflux*3.
    kntr.dotv = dotv

    # set the kntr levels based on the dynamic range of the image
    firstlev = abs(rmsflux/peakflux)*100.
    kntr.levs[1] = firstlev * (-1.)
    kntr.levs[2] = firstlev
    i = 3
    while (kntr.levs[i-1]*2. < 100. and i<=30):
        kntr.levs[i] = 2 * kntr.levs[i - 1]
        i += 1

    #for i in xrange(3,16):
    #    if kntr.levs[i] > 1:
    #        kntr.levs[i] = 0.0
    #kntr.dotv = 1
    kntr()


def runmsort(indata, outdata):
    '''Must set indata, outdata'''
    #assert(indata != None, outdata != None)

    msort = versioned_task('msort')
    msort.indata = indata
    msort.outdata = outdata
    msort()

def runvbglu(indata, in2data, outdata, in3data=None, in4data=None):

    '''Must set indata, in2data, outdata'''
    #assert (indata != None, in2data != None, outdata != None)
    vbglu = versioned_task('vbglu')
    vbglu.indata = indata
    vbglu.in2data = in2data
    if is_aipsdata(in3data):
        vbglu.in3data = in3data
    if is_aipsdata(in4data):
        vbglu.in4data = in4data
    vbglu.outdata = outdata
    #vbglu.inp()
    vbglu()

def runfxpol(indata, outdata, bandpol=''):
    '''Must set indata and outdata'''
    #assert (indata != None, outdata != None)

    fxpol = versioned_task('fxpol')
    fxpol.indata = indata
    fxpol.outdata = outdata
    fxpol.bandpol = bandpol
    fxpol.fqtol = -1
    #fxpol.inp()
    fxpol()

def runuvavg(indata, outdata, avg):
    '''Must set indata, avg'''
    #assert (indata != None, avg != None)
    uvavg = versioned_task('uvavg')
    uvavg.indata = indata
    uvavg.outdata = outdata
    uvavg.xinc = 1
    uvavg.yinc = avg
    zinc = 0
    uvavg()

def rundtsum(indata, outprint=''):
    '''Must set indata'''

    #assert (indata != None)
    dtsum = versioned_task('dtsum')
    dtsum.indata = indata
    dtsum.aparm[1] = 1.0
    dtsum.outprint = outprint
    dtsum.docrt = -1
    dtsum()

def runapcal(indata, tyver=1, gcver=1, snver=1, freqid=1):
    """Must set indata"""
    #assert (indata != None)
    apcal = versioned_task('apcal')
    apcal.indata = indata
    apcal.freqid = freqid
    apcal.tyver = tyver
    apcal.gcver = gcver
    apcal.snver = snver
    apcal.prtlev = 1
    apcal()

def runclcor(indata, clcorprm=[], opcode='PANG', gainver=0, gainuse=0,
        stokes=''):
    """must set indata"""
    #assert(indata != None)
    clcor = versioned_task('clcor')
    clcor.indata = indata
    clcor.gainver = gainver
    clcor.gainuse = gainuse
    clcor.opcode = opcode
    clcor.clcorprm[1:] = clcorprm[1:]
    clcor.stokes = stokes
    clcor()

def runvlog(indata, infile, outfile, ifwidth):

    """Must set indata, infile, outfile, ifwidth"""
    #assert(indata != None, infile != None, outfile != None, ifwidth != None)
    # use 31DEC05 for bug fix that prevents need to run clrstat afterwards
    vlog = versioned_task('vlog')
    vlog.indata = indata
    try:
        vlog.calin = infile
    except AttributeError:
        vlog.infile = infile
    vlog.outfile = outfile
    vlog.fqtol = (ifwidth * 1.e-3)/2.5      # fqtol has units of kHz
    vlog.prtlev = 1
    vlog()

def runuvcop(indata, outdata, freqid=0, bif=0, eif=0, bchan=0, echan=0,
        uvrange=[], timerang=[], antennas=[], baseline=[]):
    """Must set indata, outdata"""

    uvcop = versioned_task('uvcop')
    uvcop.indata = indata
    uvcop.outdata = outdata
    uvcop.bif = bif
    uvcop.eif = eif
    uvcop.freqid = freqid
    uvcop.bchan = bchan
    uvcop.echan = echan
    uvcop.uvrange[1:] = uvrange
    uvcop.timerang[1:] = timerang
    uvcop.antennas[1:] = antennas
    uvcop.baseline[1:] = baseline
    uvcop()

def runpcal(indata, refant='', calsour=[], timerang=[], antennas=[], uvrange=[],
        bif=0, eif=0, docalib=2, gainuse=0, pmodel=[], solint=-1, soltype='APPR'
        ):

    '''Must set indata, refant'''

    pcal = versioned_task('pcal')
    pcal.indata = indata
    pcal.refant = refant
    pcal.calsour[1:] = calsour
    pcal.timerang = timerang
    pcal.antennas = antennas
    pcal.uvrange = uvrange
    pcal.bif = bif
    pcal.eif = eif
    pcal.docalib = docalib
    pcal.gainuse = gainuse
    pcal.pmodel = pmodel
    pcal.solint = solint
    pcal.soltype = soltype
    pcal()


def runprtan(indata, outprint='', docrt=-1):
    '''Must set indata'''

    prtan = versioned_task('prtan')
    prtan.indata = indata
    prtan.outprint = outprint
    prtan.docrt = docrt
    prtan()

def runrldif(indata, source=[], timerang=[], antennas=[], uvrange=[], bif=1,
        eif=0, docalib=2, dopol=1, gainuse=0, docrt=-1, outprint=''):

    rldif = versioned_task('rldif')
    rldif.indata = indata
    rldif.source = source
    rldif.timerang = timerang
    rldif.antennas = antennas
    rldif.uvrange = uvrange
    rldif.bif = bif
    rldif.eif = eif
    rldif.docalib = docalib
    rldif.dopol = dopol
    rldif.gainuse = gainuse
    rldif.docrt = docrt
    rldif.outprint = outprint
    rldif()
    return rldif.clcorprm

def runsetjy(indata, sources=[], optype='', iflux=0, qflux=0, uflux=0, vflux=0):

    '''Must set indata'''
    setjy = versioned_task('setjy')
    setjy.indata = indata
    setjy.sources = sources
    setjy.bif = 0
    setjy.eif = 0
    setjy.zerosp[1:] = iflux, qflux, uflux, vflux
    setjy.optype = optype
    setjy()

def runprtcc(indata, invers=0, bprint=1, eprint=0, outprint=''):
    '''Must set indata'''

    prtcc = versioned_task('prtcc')
    prtcc.indata = indata
    prtcc.invers = invers
    prtcc.docell = 1
    prtcc.outprint = outprint
    prtcc()

def runcomb(indata, in2data, outdata, in3data=None, in4data=None, opcode='SUM'):
    '''Must set indata, in2data, outdata'''

    comb = versioned_task('comb')
    comb.indata = indata
    comb.in2data = in2data
    if is_aipsdata(in3data):
        comb.in3data = in3data
    if is_aipsdata(in4data):
        comb.in4data = in4data
    comb.outdata = outdata
    comb.opcode = opcode
    comb()


# the following are not actually aips tasks, but intimately connected so keep
# them here

def set_default_aparms(task):
    # simple function to set default aparms for various tasks. Returns default
    # values as a list, which can then be changed before calling the function
    # that runs the task. Note that the bparm elements match those in AIPS - do
    # not pass element zero to the tasks (e.g. use possm.aparm[1:] = aparm[1:])
    aparm = []
    aparm[1:] = [0 for i in range(10)]
    if task == 'possm':
        aparm[1] = 0
        aparm[2] = 1
        aparm[5] = -180
        aparm[6] = 180
        aparm[9] = 1

    if task == 'fring':
        aparm[1] = 3
        aparm[6] = 2
        # aparm[7] (the snr cutoff) is set in the call to fring
        #aparm[7] = 11
        aparm[9] = 1

    return aparm

def set_default_bparms(task):
    # cf aparms above
    bparm = []
    bparm[1:] = [0 for i in range(10)]
    if task == 'vplot':
        bparm[2] = -1
        bparm[3] = 1
        bparm[8] = -180
        bparm[9] = 180

    return bparm

def set_default_dparms(task):
    # cf aparms above
    dparm = []
    dparm[1:] = [0 for i in range(10)]
    if task == 'fring':
        dparm[1] = 2
        dparm[4] = 0

    return dparm


def aipsuvname(aipsdata):
    # shortcut to return the aips catalogue name of an AIPSUVData object 
    return aipsdata.name + '.' + aipsdata.klass + '.' + str(aipsdata.seq)

def split_list(list, start_index, nelem):
    '''Return the index giving the next nelem elements of list starting from
    start_index'''
    # simple function to return the index which will give the next nelem
    # elements of 'sources', starting from 'start_index'. This is useful for
    # tasks which need to have source our calsour specified as these adverbs
    # are limited to 30 elements.
    
    end_index = start_index + nelem-1
    if end_index > len(list):
        end_index = len(list)-1

    return end_index

def is_aipsdata(aipsdata):
    '''Check whether the passed object has the valid attributes for an AIPS
    data object'''

    got_attr = False
    if (hasattr(aipsdata, 'name') and hasattr(aipsdata, 'disk') and
            hasattr(aipsdata, 'seq') and hasattr(aipsdata, 'klass') ):
        got_attr = True

    return got_attr