def PCreate(name, err, input=GSolveInput): """ Create the parameters and underlying structures of a UVGSolve. Returns UVGSolve created. name = Name to be given to object Most control parameters are in InfoList member err = Python Obit Error/message stack input = control parameters: subA = Selected subarray (default 1) solInt = Solution interval (min). (default 1 sec) refAnt = Ref ant to use. (default 1) avgPol = True if RR and LL to be averaged (false) avgIF = True if all IFs to be averaged (false) minSNR = Minimum acceptable SNR (5) doMGM = True then find the mean gain modulus (true) solType = Solution type ' ', 'L1', (' ') solMode = Solution mode: 'A&P', 'P', 'P!A', 'GCON' ('P') minNo = Min. no. antennas. (default 4) WtUV = Weight outside of UV_Full. (default 1.0) antWt = Weight per antenna, def all 1 prtLv = Print level (default no print) """ ################################################################ # Checks if not OErr.OErrIsA(err): raise TypeError("err MUST be an OErr") # # Create out = UVGSolve(name) out.me = Obit.UVGSolveCreate(name, skyModel.me) # Set SelfCal control values on out inInfo = PGetList(out) # dim = [1, 1, 1, 1, 1] # Set control values on SelfCal dim[0] = 1 inInfo = UV.PGetList(skyModel) # InfoList.PPutInt(inInfo, "subA", dim, [input["subA"]], err) InfoList.PPutInt(inInfo, "refAnt", dim, [input["refAnt"]], err) InfoList.PPutInt(inInfo, "minNo", dim, [input["minNo"]], err) InfoList.PPutInt(inInfo, "prtLv", dim, [input["prtLv"]], err) InfoList.PPutBoolean(inInfo, "avgPol", dim, [input["avgPol"]], err) InfoList.PPutBoolean(inInfo, "avgIF", dim, [input["avgIF"]], err) InfoList.PPutBoolean(inInfo, "doMGM", dim, [input["doMGM"]], err) InfoList.PPutFloat(inInfo, "solInt", dim, [input["solInt"]], err) InfoList.PPutFloat(inInfo, "minSNR", dim, [input["minSNR"]], err) InfoList.PPutFloat(inInfo, "WtUV", dim, [input["WtUV"]], err) dim[0] = len(input["solType"]) InfoList.PAlwaysPutString(inInfo, "solType", dim, [input["solType"]]) dim[0] = len(input["solMode"]) InfoList.PAlwaysPutString(inInfo, "solMode", dim, [input["solMode"]]) # antWt if given if input["antWt"].__class__ != None.__class__: dim[0] = len(input["antWt"]) InfoList.PAlwaysPutFloat(inInfo, "antWt", dim, input["antWt"]) # show any errors #OErr.printErrMsg(err, "UVGSolveCreate: Error setting parameters") # return out
def VLAUVFITS(inUV, filename, outDisk, err, compress=False, \ exclude=["AIPS HI", "AIPS AN", "AIPS FQ", "AIPS SL", "AIPS PL"], \ include=[], headHi=False): """ Write UV data as FITS file Write a UV data set as a FITAB format file History written to header inUV = UV data to copy filename = name of FITS file inDisk = FITS directory number err = Python Obit Error/message stack exclude = List of table types NOT to copy NB: "AIPS HI" isn't really a table and gets copied anyway include = List of table types to copy (FQ, AN always done ) Exclude has presidence over include headHi = if True move history to header, else leave in History table returns FITS UV data object """ ################################################################ # Checks if not UV.PIsA(inUV): raise TypeError, "inUV MUST be a Python Obit UV" if not OErr.OErrIsA(err): raise TypeError, "err MUST be an OErr" # # Set output outUV = UV.newPFUV("FITS UV DATA", filename, outDisk, False, err) if err.isErr: OErr.printErrMsg(err, "Error creating FITS data") #Compressed? if compress: inInfo = UV.PGetList(outUV) # dim = [1, 1, 1, 1, 1] InfoList.PAlwaysPutBoolean(inInfo, "Compress", dim, [True]) # Copy UV.PCopy(inUV, outUV, err) if err.isErr: OErr.printErrMsg(err, "Error copying UV data to FITS") # History inHistory = History.History("inhistory", outUV.List, err) outHistory = History.History("outhistory", outUV.List, err) # Add history outHistory.Open(History.READWRITE, err) outHistory.TimeStamp(" Start Obit uvtab", err) outHistory.WriteRec( -1, "uvtab / FITS file " + filename + " disk " + str(outDisk), err) outHistory.Close(err) # History in header? if headHi: History.PCopy2Header(inHistory, outHistory, err) OErr.printErrMsg(err, "Error with history") # zap table outHistory.Zap(err) # Copy Tables UV.PCopyTables(inUV, outUV, exclude, include, err) return outUV # return new object
def PUVWeight(InImager, err, input=UVWeightInput): """ Apply any calibration/editing/selection and do UV weighting UV Data is calibrated and weighted, values in input override those given when the UVImage was created. This operation is optionally done in PUVImage. err = Python Obit Error/message stack input = input parameter dictionary Input dictionary entries: InImager = Input Python UVImager to image Robust = Briggs robust parameter. (AIPS definition) UVTaper = UV plane taper, sigma in klambda,deg as [maj, min, pa] WtSize = Size of weighting grid in cells [same as image nx] WtBox = Size of weighting box in cells [def 1] WtFunc = Weighting convolution function [def. 1] 1=Pill box, 2=linear, 3=exponential, 4=Gaussian if positive, function is of radius, negative in u and v. WtPower = Power to raise weights to. [def = 1.0] Note: a power of 0.0 sets all the output weights to 1 as modified by uniform/Tapering weighting. Applied in determinng weights as well as after. Channel = Channel (1-rel) number to image, 0-> all. """ ################################################################ # Get input parameters Channel = input["Channel"] WtSize = input["WtSize"] # # Checks if not PIsA(InImager): raise TypeError, 'PUVWeight: Bad input UVImager' # Set control values on UV dim[0] = 1 dim[1] = 1 dim[2] = 1 dim[3] = 1 dim[4] = 1 inInfo = UV.PGetList(PGetUV(InImager)) InfoList.PAlwaysPutFloat(inInfo, "Robust", dim, [input["Robust"]]) InfoList.PAlwaysPutInt(inInfo, "WtBox", dim, [input["WtBox"]]) InfoList.PAlwaysPutInt(inInfo, "WtFunc", dim, [input["WtFunc"]]) InfoList.PAlwaysPutFloat(inInfo, "WtPower", dim, [input["WtPower"]]) dim[1] = len(input["UVTaper"]) InfoList.PAlwaysPutFloat(inInfo, "Taper", dim, input["UVTaper"]) if (WtSize > 0): print "WtSize", WtSize # Change name for C routine. dim[0] = 1 InfoList.PAlwaysPutInt(inInfo, "nuGrid", dim, [WtSize]) InfoList.PAlwaysPutInt(inInfo, "nvGrid", dim, [WtSize]) # Obit.UVImagerWeight(InImager.me, err.me) if err.isErr: OErr.printErrMsg(err, "Error weighting UV data")
def PSNSmo (inSC, err, input=UVSelfSNSmoInput): """ Smooth SN table possibly replacing blanked soln. inSC = Selfcal object err = Python Obit Error/message stack input = input parameter dictionary Input dictionary entries: InData = Input Python UV data InTable = Input SN table isuba = Desired subarray, 0=> 1 smoType = Smoothing type MWF, GAUS or BOX, def BOX smoAmp = Amplitude smoothing time in min smpPhase = Phase smoothing time in min. (0 => fix failed only') """ ################################################################ # Get input parameters InData = input["InData"] InTable = input["InTable"] isuba = input["isuba"] # # Checks if not UV.PIsA(InData): raise TypeError('PCal: Bad input UV data') if not Table.PIsA(InTable): raise TypeError('PCal: Bad input table') # Set control values on UV dim[0] = 1; inInfo = UV.PGetList(InData) # Add control to UV data dim[0] = len(input["smoType"]); InfoList.PAlwaysPutString (inInfo, "smoType", dim, [input["smoType"]]) dim[0] = 1; InfoList.PPutFloat (inInfo, "smoAmp", dim, [input["smoAmp"]], err) InfoList.PPutFloat (inInfo, "smoPhase",dim, [input["smoPhase"]],err) # Smooth Obit.UVSolnSNSmo(InTable.me, isuba, err.me) if err.isErr: printErrMsg(err, "Error smoothing SN table")
def PSoln2Cal(inUV, outUV, err, input=Soln2CalInput): """ Apply a gain solution to a calibration table inUV = UV data with solution and input calibration outUV = UV data for output calibration table err = Python Obit Error/message stack input = input parameter dictionary Input dictionary entries: solnVer = Input Solution (SN) table version calIn = Input Cal (CL) table version, 0=high, -1=none calOut = Output Calibration table version, 0=>create new subA = Selected subarray (default 1) interMode = Interpolation mode 2PT, SELF POLY SIMP AMBG CUBE MWF '), "2PT " = linear vector interpolation with no SN smoothing. "SELF" = Use only SN solution from same source which is closest in time. "POLY" = Fit a polynomial to the SN rates and delays. Use the integral of the rate polynomial for the phases. (NYI) "SIMP" = Simple linear phase connection between SN phase entries, assumes phase difference less than 180 degrees. "AMBG" = Linear phase connection using rates to resolve phase ambiguities. "CUBE" = As AMBG but fit third order polynomial to phases and rates. "MWF " = Median window filter of SN table before 2PT interpolation "GAUS" = Gaussian smoothing of SN table before 2PT interpolation, "BOX " = Boxcar smoothing of SN table before 2PT interpolation, interParm = interpolation parameters, smoothing time (hr) amplitude, phase, delay/rate interNPoly = number of terms in polynomial'), allPass = If true copy unmodified entries as well (default False) refAnt = Ref ant to use. (default 1) """ ################################################################ # Get input parameters InData = input["InData"] InTable = input["InTable"] isuba = input["isuba"] # # Checks if not UV.PIsA(inUV): raise TypeError, 'PSoln2Cal: Bad input UV data' if not UV.PIsA(outUV): raise TypeError, 'PSoln2Cal: Bad output UV data' # Set control values on UV dim[0] = 1 inInfo = UV.PGetList(InData) # Add control to UV data dim[0] = 4 InfoList.PAlwaysPutString(inInfo, "interMode", dim, [input["interMode"]]) dim[0] = 1 InfoList.PAlwaysPutInt(inInfo, "solnVer", dim, [input["solnVer"]]) InfoList.PAlwaysPutInt(inInfo, "calIn", dim, [input["calIn"]]) InfoList.PAlwaysPutInt(inInfo, "calOut", dim, [input["calOut"]]) InfoList.PAlwaysPutInt(inInfo, "subA", dim, [input["subA"]]) InfoList.PAlwaysPutInt(inInfo, "interNPoly", dim, [input["interNPoly"]]) InfoList.PAlwaysPutInt(inInfo, "refAnt", dim, [input["refAnt"]]) InfoList.PAlwaysPutBool(inInfo, "allPass", dim, [input["allPass"]]) dim[0] = len(input["interParm"]) InfoList.PAlwaysPutFloat(inInfo, "allPass", dim, input["interParm"]) # Calibrate Obit.UVSoln2Cal(inUV, outUV, err) if err.isErr: printErrMsg(err, "Error applying SN table to CL table")
def PUVCreateImager(err, name='myUVImager', input=UVCreateImagerInput): """ Create an imager to generate a set of images needed to cover a region. Create and return a Python Obit UVImager based on input parameters and uv data to be imaged. Images should be fully defined when returned. err = Python Obit Error/message stack name = Name for output object input = input parameter dictionary Input dictionary entries: InData = Input Python UV data to image doCalSelect = Select/calibrate/edit data?), Stokes = Stokes parameter, blank-> unchanged from input), BChan = First spectral channel selected. [def all]), EChan = Highest spectral channel selected. [def all]), BIF = First IF selected. [def all]), EIF = Highest IF selected. [def all]), doPol = >0 -> calibrate polarization.), doCalib = >0 -> calibrate, 2=> also calibrate Weights), gainUse = SN/CL table version number, 0-> use highest), flagVer = Flag table version, 0-> use highest, <0-> none), BLVer = BL table version, 0> use highest, <0-> none), BPVer = Band pass (BP) table version, 0-> use highest), Subarray = Selected subarray, <=0->all [default all]), freqID = Selected Frequency ID, <=0->all [default all]), timeRange= Selected timerange in days. [2 floats] 0s -> all), UVRange = Selected UV range in wavelengths. 0s -> all), Sources = Source names selected unless any starts with), Antennas = A list of selected antenna numbers, if any is negative), corrType = Correlation type, 0=cross corr only, 1=both, 2=auto only.), doBand = Band pass application type <0-> none), Smooth = Specifies the type of spectral smoothing [three floats] DoWeight = True if Weighting to be applied Robust = Briggs robust parameter. (AIPS definition) UVTaper = UV plane taper, sigma in klambda,deg as [maj, min, pa] WtSize = Size of weighting grid in cells [same as image nx] WtBox = Size of weighting box in cells [def 1] WtFunc = Weighting convolution function [def. 1] 1=Pill box, 2=linear, 3=exponential, 4=Gaussian if positive, function is of radius, negative in u and v. WtPower = Power to raise weights to. [def = 1.0] Note: a power of 0.0 sets all the output weights to 1 as modified by uniform/Tapering weighting. Applied in determinng weights as well as after. DoBeam = True if beams are to be made Type = Underlying file type, 0=FITS, 1=AIPS Name = Name of image, used as AIPS name or to derive FITS filename Class = Root of class, used as AIPS class or to derive FITS filename Seq = Sequence number Disk = Disk number for underlying files FOV = Field of view (deg) for Mosaic doFull = If True, create full field (FOV) image NField = Number of fields defined in input, if unspecified derive from data and FOV xCells = Cell spacing in X (asec) for all images, if unspecified derive from data yCells = Cell spacing in Y (asec) for all images, if unspecified derive from data nx = Minimum number of cells in X for NField images if unspecified derive from data ny = Minimum number of cells in Y for NField images if unspecified derive from data RAShift = Right ascension shift (AIPS convention) for each field if unspecified derive from FOV and data DecShift = Declination for each field if unspecified derive from FOV and data Catalog = AIPSVZ format catalog for defining outliers, None=do not use OutlierFlux = Minimum estimated outlyer flux density (Jy) OutlierDist = Maximum distance to add outlyers (deg) OutlierSI = Spectral index to estimate flux density OutlierSize = Size of outlyer field (pixels) returns = Output UVImager with defined ImageMosaic """ ################################################################ # Get input parameters InData = input["InData"] # # Checks if not UV.PIsA(InData): raise TypeError, 'UVCreateImage: Bad input UV data' # Set control values on UV dim[0] = 1 dim[1] = 1 dim[2] = 1 dim[3] = 1 dim[4] = 1 inInfo = UV.PGetList(InData) # Add control to UV data # Calibration/editing/selection InfoList.PAlwaysPutBoolean(inInfo, "doCalSelect", dim, [input["doCalSelect"]]) dim[0] = 4 InfoList.PAlwaysPutString(inInfo, "Stokes", dim, [input["Stokes"]]) dim[0] = 1 InfoList.PAlwaysPutInt(inInfo, "BChan", dim, [input["BChan"]]) InfoList.PAlwaysPutInt(inInfo, "EChan", dim, [input["EChan"]]) InfoList.PAlwaysPutInt(inInfo, "BIF", dim, [input["BIF"]]) InfoList.PAlwaysPutInt(inInfo, "EIF", dim, [input["EIF"]]) itemp = int(input["doPol"]) InfoList.PAlwaysPutInt(inInfo, "doPol", dim, [itemp]) InfoList.PAlwaysPutInt(inInfo, "doCalib", dim, [input["doCalib"]]) InfoList.PAlwaysPutInt(inInfo, "doBand", dim, [input["doBand"]]) InfoList.PAlwaysPutInt(inInfo, "gainUse", dim, [input["gainUse"]]) InfoList.PAlwaysPutInt(inInfo, "flagVer", dim, [input["flagVer"]]) InfoList.PAlwaysPutInt(inInfo, "BLVer", dim, [input["BLVer"]]) InfoList.PAlwaysPutInt(inInfo, "BPVer", dim, [input["BPVer"]]) InfoList.PAlwaysPutInt(inInfo, "Subarray", dim, [input["Subarray"]]) InfoList.PAlwaysPutInt(inInfo, "freqID", dim, [input["freqID"]]) InfoList.PAlwaysPutInt(inInfo, "corrType", dim, [input["corrType"]]) dim[0] = 2 InfoList.PAlwaysPutFloat(inInfo, "UVRange", dim, input["UVRange"]) dim[0] = 3 InfoList.PAlwaysPutFloat(inInfo, "Smooth", dim, input["Smooth"]) dim[0] = 2 InfoList.PAlwaysPutFloat(inInfo, "timeRange", dim, input["timeRange"]) dim[0] = len(input["Antennas"]) InfoList.PAlwaysPutInt(inInfo, "Antennas", dim, input["Antennas"]) dim[0] = 16 dim[1] = len(input["Sources"]) InfoList.PAlwaysPutString(inInfo, "Sources", dim, input["Sources"]) # Weighting parameters dim[0] = 1 dim[1] = 1 InfoList.PAlwaysPutFloat(inInfo, "Robust", dim, [input["Robust"]]) InfoList.PAlwaysPutInt(inInfo, "WtBox", dim, [input["WtBox"]]) InfoList.PAlwaysPutInt(inInfo, "WtFunc", dim, [input["WtFunc"]]) InfoList.PAlwaysPutFloat(inInfo, "WtPower", dim, [input["WtPower"]]) dim[0] = len(input["UVTaper"]) InfoList.PAlwaysPutFloat(inInfo, "UVTaper", dim, input["UVTaper"]) WtSize = input["WtSize"] if (WtSize > 0): print "WtSize", WtSize # Change name for C routine. dim[0] = 1 InfoList.PAlwaysPutInt(inInfo, "nuGrid", dim, [WtSize]) InfoList.PAlwaysPutInt(inInfo, "nvGrid", dim, [WtSize]) # Define image dim[0] = 1 dim[1] = 1 InfoList.PAlwaysPutInt(inInfo, "imFileType", dim, [input["Type"]]) InfoList.PAlwaysPutInt(inInfo, "imSeq", dim, [input["Seq"]]) InfoList.PAlwaysPutInt(inInfo, "imDisk", dim, [input["Disk"]]) InfoList.PAlwaysPutFloat(inInfo, "FOV", dim, [input["FOV"]]) InfoList.PAlwaysPutBoolean(inInfo, "doFull", dim, [input["doFull"]]) InfoList.PAlwaysPutInt(inInfo, "NField", dim, [input["NField"]]) InfoList.PAlwaysPutFloat(inInfo, "xCells", dim, [input["xCells"]]) InfoList.PAlwaysPutFloat(inInfo, "yCells", dim, [input["yCells"]]) InfoList.PAlwaysPutFloat(inInfo, "OutlierFlux", dim, [input["OutlierFlux"]]) InfoList.PAlwaysPutFloat(inInfo, "OutlierDist", dim, [input["OutlierDist"]]) InfoList.PAlwaysPutFloat(inInfo, "OutlierSI", dim, [input["OutlierSI"]]) InfoList.PAlwaysPutInt(inInfo, "OutlierSize", dim, [input["OutlierSize"]]) dim[0] = len(input["Name"]) InfoList.PAlwaysPutString(inInfo, "imName", dim, [input["Name"]]) dim[0] = len(input["Class"]) InfoList.PAlwaysPutString(inInfo, "imClass", dim, [input["Class"]]) dim[0] = len(input["Catalog"]) InfoList.PAlwaysPutString(inInfo, "Catalog", dim, [input["Catalog"]]) dim[0] = len(input["nx"]) InfoList.PAlwaysPutInt(inInfo, "nx", dim, input["nx"]) dim[0] = len(input["ny"]) InfoList.PAlwaysPutInt(inInfo, "ny", dim, input["ny"]) dim[0] = len(input["RAShift"]) InfoList.PAlwaysPutFloat(inInfo, "RAShift", dim, input["RAShift"]) dim[0] = len(input["DecShift"]) InfoList.PAlwaysPutFloat(inInfo, "DecShift", dim, input["DecShift"]) # # Create out = UVImager(name, InData.me, err.me) # show any errors #OErr.printErrMsg(err, "UVImage: Error creating UVImager object") # return out
def PCreate (name, uvdata, err, input=CleanInput): """ Create the parameters and underlying structures of a CleanVis. Returns CleanVis created. * name = Name to be given to object. Most control parameters are in InfoList member * uvdata = Python uv data from which image is to be made * err = Python Obit Error/message stack * input = control parameters: =========== ============================================================ Niter Maximum number of CLEAN iterations minPatch Minimum beam patch in pixels [def 100] maxPixel Maximum number of residuals [def 20000] BMAJ Restoring beam major axis (deg) BMIN Restoring beam minor axis (deg) BPA Restoring beam position angle (deg) Gain CLEAN loop gain minFlux Minimun flux density (Jy) Factor CLEAN depth factor Plane Plane being processed, 1-rel indices of axes 3-? autoWindow True if autoWindow feature wanted. CCVer CC table version number Mode Model mode, 0=fastest, 1=DFT, 2=Grid doCalSelect Select/calibrate/edit data?), Stokes Stokes parameter, blank-> unchanged from input), BChan First spectral channel selected. [def all]), EChan Highest spectral channel selected. [def all]), BIF First IF selected. [def all]), EIF Highest IF selected. [def all]), doPol >0 -> calibrate polarization.), doCalib >0 -> calibrate, 2=> also calibrate Weights), gainUse SN/CL table version number, 0-> use highest), flagVer Flag table version, 0-> use highest, <0-> none), BLVer BL table version, 0> use highest, <0-> none), BPVer Band pass (BP) table version, 0-> use highest), Subarray Selected subarray, <=0->all [default all]), freqID Selected Frequency ID, <=0->all [default all]), timeRange Selected timerange in days. [2 floats] 0s -> all), UVRange Selected UV range in wavelengths. 0s -> all), Sources Source names selected unless any starts with), Antennas A list of selected antenna numbers, if any is negative), corrType Correlation type, 0=cross corr only, 1=both, 2=auto only.), doBand Band pass application type <0-> none), Smooth Specifies the type of spectral smoothing [three floats] DoWeight True if Weighting to be applied PBCor If True make freq. dependent rel. pri. beam corr. Robust Briggs robust parameter. (AIPS definition) UVTaper UV plane taper, sigma in klambda,deg as [maj, min, pa] WtSize Size of weighting grid in cells [same as image nx] WtBox Size of weighting box in cells [def 1] WtFunc Weighting convolution function [def. 1] 1=Pill box, 2=linear, 3=exponential, 4=Gaussian if positive, function is of radius, negative in u and v. WtPower Power to raise weights to. [def = 1.0] Note: a power of 0.0 sets all the output weights to 1 as modified by uniform/Tapering weighting. Applied in determinng weights as well as after. DoBeam True if beams are to be made Type Underlying file type, 0=FITS, 1=AIPS Name Name of image, used as AIPS name or to derive FITS filename Class Root of class, used as AIPS class or to derive FITS filename Seq Sequence number Disk Disk number for underlying files FOV Field of view (deg) for Mosaic doFull If True, create full field (FOV) image NField Number of fields defined in input, if unspecified derive from data and FOV xCells Cell spacing in X (asec) for all images, if unspecified derive from data yCells Cell spacing in Y (asec) for all images, if unspecified derive from data nx Minimum number of cells in X for NField images if unspecified derive from data ny Minimum number of cells in Y for NField images if unspecified derive from data RAShift Right ascension shift (AIPS convention) for each field if unspecified derive from FOV and data DecShift Declination for each field if unspecified derive from FOV and data Catalog AIPSVZ format catalog for defining outliers, None=do not use OutlierFlux Minimum estimated outlyer flux density (Jy) OutlierDist Maximum distance to add outlyers (deg) OutlierSI Spectral index to estimate flux density OutlierSize Size of outlyer field (pixels) dispURL URL of display server doRestore Restore image when done? [def True] doFlatten Flatten image when done? [def True] =========== ============================================================ """ ################################################################ # Checks if not UV.PIsA(uvdata): raise TypeError,"uvData MUST be a Python Obit UV" if not OErr.OErrIsA(err): raise TypeError,"err MUST be an OErr" # dim = [1,1,1,1,1] # Set imaging control values on uvdata dim[0] = 1; inInfo = UV.PGetList(uvdata) # InfoList.PPutBoolean (inInfo, "doCalSelect", dim, [input["doCalSelect"]], err) dim[0] = 4 InfoList.PAlwaysPutString (inInfo, "Stokes", dim, [input["Stokes"]]) dim[0] = 1; InfoList.PPutInt (inInfo, "BChan", dim, [input["BChan"]], err) InfoList.PPutInt (inInfo, "EChan", dim, [input["EChan"]], err) InfoList.PPutInt (inInfo, "BIF", dim, [input["BIF"]], err) InfoList.PPutInt (inInfo, "EIF", dim, [input["EIF"]], err) itemp = int(input["doPol"]) InfoList.PPutInt (inInfo, "doPol", dim, [itemp], err) InfoList.PPutInt (inInfo, "doCalib", dim, [input["doCalib"]], err) InfoList.PPutInt (inInfo, "doBand", dim, [input["doBand"]], err) InfoList.PPutInt (inInfo, "gainUse", dim, [input["gainUse"]], err) InfoList.PPutInt (inInfo, "flagVer", dim, [input["flagVer"]], err) InfoList.PPutInt (inInfo, "BLVer", dim, [input["BLVer"]], err) InfoList.PPutInt (inInfo, "BPVer", dim, [input["BPVer"]], err) InfoList.PPutInt (inInfo, "Subarray", dim, [input["Subarray"]], err) InfoList.PPutInt (inInfo, "freqID", dim, [input["freqID"]], err) InfoList.PPutInt (inInfo, "corrType", dim, [input["corrType"]], err) dim[0] = 2 InfoList.PPutFloat (inInfo, "UVRange", dim, input["UVRange"], err) dim[0] = 3 InfoList.PPutFloat (inInfo, "Smooth", dim, input["Smooth"], err) dim[0] = 2 InfoList.PPutFloat (inInfo, "timeRange", dim, input["timeRange"], err) dim[0] = len(input["Antennas"]) InfoList.PPutInt (inInfo, "Antennas", dim, input["Antennas"], err) dim[0] = 16; dim[1] = len(input["Sources"]) InfoList.PAlwaysPutString (inInfo, "Sources", dim, input["Sources"]) # Weighting parameters dim[0] = 1; dim[1] = 1; InfoList.PPutBoolean (inInfo,"DoWeight",dim,[input["DoWeight"]],err) InfoList.PPutBoolean (inInfo,"PBCor", dim, [input["PBCor"]], err) InfoList.PPutFloat (inInfo, "Robust", dim, [input["Robust"]], err) InfoList.PPutInt (inInfo, "WtBox", dim, [input["WtBox"]], err) InfoList.PPutInt (inInfo, "WtFunc", dim, [input["WtFunc"]], err) InfoList.PPutFloat (inInfo, "WtPower",dim, [input["WtPower"]], err) dim[1] = len(input["UVTaper"]) InfoList.PPutFloat (inInfo, "Taper", dim, input["UVTaper"], err) WtSize = input["WtSize"] if (WtSize>0): print "WtSize", WtSize # Change name for C routine. dim[0] = 1; InfoList.PPutInt (inInfo, "nuGrid", dim, [WtSize], err) InfoList.PPutInt (inInfo, "nvGrid", dim, [WtSize], err) # Define image dim[0] = 1; dim[1] = 1; InfoList.PPutInt (inInfo, "imFileType", dim, [input["Type"]], err) InfoList.PPutInt (inInfo, "imSeq", dim, [input["Seq"]], err) InfoList.PPutInt (inInfo, "imDisk", dim, [input["Disk"]], err) InfoList.PPutFloat (inInfo, "FOV", dim, [input["FOV"]], err) InfoList.PPutBoolean (inInfo, "doFull", dim, [input["doFull"]], err) InfoList.PPutInt (inInfo, "NField", dim, [input["NField"]], err) InfoList.PPutFloat (inInfo, "xCells", dim, [input["xCells"]], err) InfoList.PPutFloat (inInfo, "yCells", dim, [input["yCells"]], err) InfoList.PPutFloat (inInfo, "OutlierFlux", dim, [input["OutlierFlux"]], err) InfoList.PPutFloat (inInfo, "OutlierDist", dim, [input["OutlierDist"]], err) InfoList.PPutFloat (inInfo, "OutlierSI", dim, [input["OutlierSI"]], err) InfoList.PPutInt (inInfo, "OutlierSize", dim, [input["OutlierSize"]], err) InfoList.PPutFloat (inInfo, "BMAJ", dim, [input["BMAJ"]], err) InfoList.PPutFloat (inInfo, "BMIN", dim, [input["BMIN"]], err) InfoList.PPutFloat (inInfo, "BPA", dim, [input["BPA"]], err) dim[0] = len(input["Name"]) InfoList.PAlwaysPutString (inInfo, "imName", dim, [input["Name"]]) dim[0] = len(input["Class"]) InfoList.PAlwaysPutString (inInfo, "imClass", dim, [input["Class"]]) dim[0] = len(input["Catalog"]) InfoList.PAlwaysPutString (inInfo, "Catalog", dim, [input["Catalog"]]) dim[0] = len(input["nx"]) InfoList.PAlwaysPutInt (inInfo, "nx", dim, input["nx"]) dim[0] = len(input["ny"]) InfoList.PAlwaysPutInt (inInfo, "ny", dim, input["ny"]) dim[0] = len(input["RAShift"]) InfoList.PAlwaysPutFloat (inInfo, "RAShift", dim, input["RAShift"]) dim[0] = len(input["DecShift"]) InfoList.PAlwaysPutFloat (inInfo, "DecShift", dim, input["DecShift"]) #OErr.printErrMsg(err, "CleanVisCreate: Error setting parameters") # # Create out = CleanVis(name); out.me = Obit.CleanVisCreate(name, uvdata.me, err.me) if err.isErr: OErr.printErrMsg(err, "Error creating CleanVis") # Set Clean control values on out dim[0] = 1; inInfo = PGetList(out) # InfoList.PPutInt (inInfo, "Niter", dim, [input["Niter"]], err) InfoList.PPutInt (inInfo, "minPatch", dim, [input["minPatch"]], err) InfoList.PPutInt (inInfo, "maxPixel", dim, [input["maxPixel"]], err) InfoList.PPutInt (inInfo, "CCVer", dim, [input["CCVer"]], err) InfoList.PPutInt (inInfo, "Mode", dim, [input["Mode"]], err) InfoList.PPutFloat (inInfo, "BMAJ", dim, [input["BMAJ"]], err) InfoList.PPutFloat (inInfo, "BMIN", dim, [input["BMIN"]], err) InfoList.PPutFloat (inInfo, "BPA", dim, [input["BPA"]], err) InfoList.PPutFloat (inInfo, "Gain", dim, [input["Gain"]], err) InfoList.PPutFloat (inInfo, "minFlux", dim, [input["minFlux"]], err) InfoList.PPutFloat (inInfo, "Factor", dim, [input["Factor"]], err) InfoList.PPutBoolean (inInfo, "doRestore", dim, [input["doRestore"]], err) InfoList.PPutBoolean (inInfo, "doFlatten", dim, [input["doFlatten"]], err) InfoList.PPutBoolean (inInfo, "autoWindow", dim, [input["autoWindow"]],err) dim[0] = len(input["Plane"]) InfoList.PAlwaysPutInt (inInfo, "Plane", dim, input["Plane"]) dim[0] = len(input["dispURL"]) InfoList.PAlwaysPutString (inInfo, "dispURL", dim, [input["dispURL"]]) # show any errors #OErr.printErrMsg(err, "CleanVisCreate: Error setting parameters") # return out;