def PParse(infile, list, err):
""" Parse text file
Parse parameter format text file and copy to list
The input file is basically free format with a keyword=value syntax.
Comments follow a "#" symbol. String keywords should have no leading or
trailing blanks before the end of the line or a comment delimiter.
If a numeric value is followed by a comment there should be at least one
blank before the comment delimiter. Allowed types are:
Str (String), Flt (float), Dbl (double), Int (int), Boo (boolean)
Examples:
# Comment
$Key = SomeStr Str (9) # Some string
Something
$Key = FArr Flt (2) # Array of 2 floats
0.0 0.0
$Key = CLEANBox Int(4,1) # Clean box with 4 ints
0 0 0 0
returns 0 on success, else 1
infile = Name of the input text file to parse
list = ObitInfoList to accept values.
err = ObitErr for reporting errors.
"""
################################################################
# Checks
if not InfoList.PIsA(list):
raise TypeError,"list MUST be a Python Obit InfoList"
ret = Obit.Parse(infile, list.me, err.me)
if ret or err.isErr:
OErr.printErrMsg(err, "Error Parsing "+infile)
return ret
def PCvtPixel(inID, inPixel, outID, err):
"""
Return pixel location in outID corresponding to pixel inPixel in inID
returns array of 2 floats giving pixel position in outID.
* inID = Python Obit ImageDesc for input
* inPixel = array of floats giving position in image described by inID
only first 2 used.
* outID = Python Obit ImageDesc for output
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inID):
raise TypeError("inID MUST be a Python Obit ImageDesc")
if not PIsA(outID):
raise TypeError("outID MUST be a Python Obit ImageDesc")
if not OErr.OErrIsA(err):
raise TypeError("err MUST be an OErr")
if inPixel[0].__class__ != float:
print("class is", inPixel[0].__class__)
raise TypeError("inPixel MUST be float")
if len(inPixel) < 2:
raise RuntimeError("inPixel has fewer then 2 entries")
#
outTmp = Obit.ImageDescCvtPixel(inID.me, outID.me, inPixel, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error converting pixel location")
out = outTmp[0:2]
return out
def DescMakeIF(outUV, nIF, err):
"""
Convert outUV descriptor divided into nIF IFs
* outUV = output Obit UV object
* nIF = number of desired output IFs
MUST be the same number of channels per IF
* err = Obit error/message stack
"""
################################################################
d = outUV.Desc.Dict
# Have IF axis?
if d["jlocif"] >= 0:
jlocif = d["jlocif"]
else: # create one
jlocif = d['naxis']
d['naxis'] += 1
d['ctype'][jlocif] = "IF"
d['crval'][jlocif] = 1.0
d['crpix'][jlocif] = 1.0
d['cdelt'][jlocif] = 1.0
d['crota'][jlocif] = 0.0
jlocf = d["jlocf"]
nchan = d["inaxes"][jlocf] / nIF
d["inaxes"][jlocif] = nIF
d["inaxes"][jlocf] = nchan
outUV.Desc.Dict = d
UV.PGetIODesc(outUV).Dict = d # And your little dog too
# Update
outUV.UpdateDesc(err)
outUV.Open(UV.WRITEONLY, err)
outUV.Close(err)
#outUV.Header(err)
OErr.printErrMsg(err, "Error converting Descriptor")
def ClearErr(err=err):
""" Print any errors and clear stack
err = Python Obit Error/message stack, default of PTObit version
"""
################################################################
OErr.printErrMsg(err, "Error")
def getname(cno, disk=Adisk):
""" Return Obit object for AIPS file in cno on disk
cno = AIPS catalog slot number
disk = AIPS disk number
"""
################################################################
Adisk = disk
user = AIPS.AIPS.userno
s = AIPSDir.PInfo(disk, user, cno, err)
OErr.printErrMsg(err, "Error with AIPS catalog")
# parse returned string
Aname = s[0:12]
Aclass = s[13:19]
Aseq = int(s[20:25])
Atype = s[26:28]
if Atype == 'MA':
out = Image.newPAImage("AIPS image", Aname, Aclass, disk, Aseq, True, err)
print "AIPS Image",Aname, Aclass, disk, Aseq
elif Atype == 'UV':
out = UV.newPAUV("AIPS UV data", Aname, Aclass, disk, Aseq, True, err)
print "AIPS UV",Aname, Aclass, disk, Aseq
out.Aname = Aname
out.Aclass = Aclass
out.Aseq = Aseq
out.Atype = Atype
out.Disk = disk
out.Acno = cno
return out
def PWebFetch(url, args, outfile, err):
"""
Generic Fetch a web product
Sends a http post request to url and sames response to outfile
Throws exception on error
* url = where the request to be sent,
e.g."https://www.cv.nrao.edu/cgi-bin/postage.pl"
* args = dict or arguments, e.g. {"arg1":"arg1"}
* outfile = Name of the output file, absolute path or relative to CWD
None => use name from server
* err = Python Obit Error/message stack
"""
################################################################
# Package parameters
encoded_args = urllib.urlencode(args)
NVSShost = "https://www.cv.nrao.edu/cgi-bin/postage.pl"
# fetch
try:
request = urllib2.Request(url)
response = urllib2.urlopen(request, encoded_args)
data = response.read()
except Exception, exception:
print exception
OErr.PLog(err, OErr.Error, "Request from server failed")
OErr.printErrMsg(err)
def PPutBoolean (inList, name, dim, data, err):
""" Add an boolean entry (1,0), error if conflict
inList = input Python InfoList
name = name of desired entry
dim = dimensionality of array as list, e.g. [1,1,1,1,1] for scalar
MUST have 5 entries
data = data as a 1-D array of boolean (1,0)
err = Python Obit Error/message stack
"""
################################################################
# Checks
if data[0].__class__ != bool:
print "class is" , data[0].__class__
raise TypeError,"data MUST be bool"
if len(dim) < 5:
raise RuntimeError,"dim has fewer then 5 entries"
prod = 1
for x in dim:
if (x>0):
prod = prod*x
if prod < len(data):
raise RuntimeError,"more data than defined in dim"
if prod > len(data):
raise RuntimeError,"less data than defined in dim"
Obit.InfoListPutBoolean(inList.me, name, dim, data, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error adding entry")
def PAddDir(newDir, err, URL=None):
""" Add a new FITS directory
returns FITS disk number
newDir = new directory path
err = Python Obit Error/message stack
URL = URL if on a remote host (Only if using OTObit/ParselTongue)
"""
################################################################
global FITSdisks, nFITS
# Checks
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
retDisk = Obit.FITSAddDir(newDir, err.me)
FITSdisks.append(newDir)
nFITS = len(FITSdisks)
#print "DEBUG nFITS",nFITS
if err.isErr:
OErr.printErrMsg(err, "Error adding FITS directory")
# Update ObitTalk stuff
try:
FITS.FITS.disks.append(FITS.FITSDisk(URL, retDisk, newDir))
except:
pass
else:
pass
return retDisk;
def __init__(self):
"""
Constructor
Largely derived from
https://github.com/bill-cotton/Obit/blob/master/ObitSystem/Obit/share/scripts/AIPSSetup.py
"""
# Get the current configuration
cfg = kc.get_config()
self.err = err = OErr.OErr()
self.obitsys = OSystem.OSystem("Pipeline", 1, cfg['userno'], 0, [" "],
0, [" "], True, False, err)
OErr.printErrMsg(err, "Error starting Obit System")
# Setup AIPS userno
AIPS.userno = cfg['userno']
# Setup Obit Environment
ObitTalkUtil.SetEnviron(AIPS_ROOT=cfg['aipsroot'],
AIPS_VERSION=cfg['aipsversion'],
OBIT_EXEC=cfg['obitexec'],
DA00=cfg['da00'],
ARCH="LINUX",
aipsdirs=cfg['aipsdirs'],
fitsdirs=cfg['fitsdirs'])
def PAddDir(newDir, err, URL=None):
"""
Add a new FITS directory
returns FITS disk number
* newDir = new directory path
* err = Python Obit Error/message stack
* URL = URL if on a remote host (Only if using OTObit/ParselTongue)
"""
################################################################
global FITSdisks, nFITS
# Checks
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
retDisk = Obit.FITSAddDir(newDir, err.me)
FITSdisks.append(newDir)
nFITS = len(FITSdisks)
#print "DEBUG nFITS",nFITS
if err.isErr:
OErr.printErrMsg(err, "Error adding FITS directory")
# Update ObitTalk stuff
try:
FITS.FITS.disks.append(FITS.FITSDisk(URL, retDisk, newDir))
except:
pass
else:
pass
return retDisk
def PTableCCT2Spec (inImage, outImage, nTerm,
inCCVer, outCCVer, err, startCC=0, endCC=0):
""" Convert an (tabulated) TSpec CC Table to spectral parameter table
Output CC Table will have fitted spectra rather than tabulated spectra.
Tabulated spectrum fitted with spectrum weighting by primary beam
inImage input Obit Python Image 1
Must have freq axis type = "SPECLNMF"
Optional parameters on List member:
"dropNeg" boolean if True drop negative components [True]
"doPBCor" boolean if True Primary beam correct [False]
outImage output Obit Python image must be type ObitImageWB
This can be created by ImageUtil.PImageT2Spec
nTerm Number of output Spectral terms, 2=SI, 3=also curve.
inCCVer Input CCTable to convert, 0=> highest
outCCVer Output CCTable, 0=>1
err Python Obit Error/message stack
startCC First 1-rel component to convert
endCC Last 1-rel component to convert, 0=> all
"""
################################################################
# Checks
if not Image.PIsA(inImage):
raise TypeError,"inImage MUST be a Python Obit Image"
if not Image.PIsA(outImage):
raise TypeError,"outImage MUST be a Python Obit Image"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
Obit.TableCCUtilT2Spec(inImage.me, outImage.me, nTerm, inCCVer, \
outCCVer, startCC, endCC, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error Converting CC Table")
def PPutString (inList, name, dim, data, err):
""" Add an string entry, error if conflict
inList = input Python InfoList
name = name of desired entry
dim = dimensionality of array as list, e.g. [1,1,1,1,1] for scalar
MUST have 5 entries
data = data as a 1-D array of strings (rectangular char array)
err = Python Obit Error/message stack
"""
################################################################
# Checks
if data[0].__class__ != str:
print "class is" , data[0].__class__
raise TypeError,"data MUST be a string"
if len(dim) < 5:
raise RuntimeError,"dim has fewer then 5 entries"
prod = 1
for x in dim:
if (x>0):
prod = prod*x
if prod < len(data):
raise RuntimeError,"more data than defined in dim"
# Call depends on whether single string, 1 or 2 D arrays
if (dim[1]>1): # array of strings
Obit.InfoListPutString(inList.me, name, dim, data, err.me)
else: # single
Obit.InfoListPutSString(inList.me, name, dim, data, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error adding entry")
def PSetDir(disk, newName, err, URL=None):
"""
Set the directory name for a given AIPS directory
returns disk number actually used
* disk = AIPS disk number, <=0 => assign
* newName = new directory path
* err = Python Obit Error/message stack
* URL = URL if on a remote host (Only if using OTObit/ParselTongue)
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
retDisk = Obit.AIPSSetDirname(disk, newName, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error setting AIPS directory name")
AIPSdisks.append(newName)
nAIPS = len(AIPSdisks)
if (disk <= 0):
try:
AIPS.AIPS.disks.append(AIPS.AIPSDisk(URL, retDisk, newName))
except:
pass
else:
pass
return retDisk
def PNVSSFetch (RA, Dec, outfile, err, \
Type = 'image/xfits', Equinox = '2000', \
ObjName='unnamed', Size = '0.50 0.50', \
Poltype = 'I', MAPROJ = 'SIN',
rotate = 0.0, Cells=[15.,15.]):
"""
Postage Stamp server for the NRAO/VLA Sky Survey (1.4 GHz)
Fetch a postage stamp (AKA cutout) FITS image, jpeg or contour from the NVSS
If a FITS file, returns an ObitImage object pointing to the result,
otherwise the output file name
If something goes wrong with the request or download, the output file
will likely contain an HTML file explaining the results.
Throws exception on error
* RA = Right Ascension as 'hh mm ss.sss'
* Dec = Declination as 'sdd mm ss.ss'
* outfile = Name of the output file, absolute path or relative to CWD
None => use name from server
* err = Python Obit Error/message stack
* Type = Type = "type" of result;
'image/jpeg' = jpeg image,
'application/octet-stream' = fits file
'application/postscript' = contour plot (postscript)
'image/x-fits' = fits image
(default = /image/jpeg)
* Equinox = coordinate equinox ('2000' or '1950')
* ObjName = object name - used for labeling only (optional)
* Size = field size (RA,dec) in deg. (default 0.50 0.50)
* Poltype = total intensity 'I' or 'IQU' (default 'I')
* MAPROJ = Map projection type: 'SIN', 'TAN', 'ARC', 'NCP',
'GLS', 'MER', 'AIT','STG'
* rotate = Rotation on sky in deg in sense of from North to East
* Cells = pixel spacing in aseconds (default 15. 15.)
"""
################################################################
# Package parameters
query_args = {
'Type': Type,
'Equinox': Equinox,
'ObjName': ObjName,
'RA': RA,
'Dec': Dec,
'Size': Size,
'Poltype': Poltype,
'MAPROJ': MAPROJ,
'rotate': str(rotate),
'Cells': str(Cells[0]) + ' ' + str(Cells[1])
}
NVSSURL = "https://www.cv.nrao.edu/cgi-bin/postage.pl"
# fetch
PWebFetch(NVSSURL, query_args, outfile, err)
# Get fits image if requested
if (Type == 'image/x-fits') or (Type == 'application/octet-stream'):
#print "Get FITS"
outfits = Image.newPFImage(ObjName, outfile, 0, True, err)
OErr.printErrMsg(err,
"Problem with FITS image, see contents of outfile")
else:
return outfile
return outfits
def VLAClearCal(uv, err, doGain=True, doBP=False, doFlag=False):
""" Clear previous calibration
Delete all SN tables, all CL but CL 1
uv = UV data object to clear
err = Obit error/message stack
doGain = If True, delete SN and CL tables
doBP = If True, delete BP tables
doFlag = If True, delete FG tables
"""
################################################################
# Gain tables
if doGain:
uv.ZapTable("AIPS SN",-1,err)
ver = uv.GetHighVer("AIPS CL")
while (ver>1):
uv.ZapTable ('AIPS CL', ver, err)
ver = ver-1
# Bandpass
if doBP:
uv.ZapTable("AIPS BP",-1,err)
# Flag tables
if doFlag:
uv.ZapTable("AIPS FG",-1,err)
OErr.printErrMsg(err, "VLAClearCal: Error reseting calibration")
def PEdit (inHis, startr, endr, err):
"""
Edit History
Deletes a range of history records.
return 0 on success, else failure
* inHis = input Python History
* startr = first (1-rel) history record to delete
* endr = highest (1-rel) history record to delete, 0=>to end
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inHis):
raise TypeError("inHis MUST be a History")
if not OErr.OErrIsA(err):
raise TypeError("err MUST be an OErr")
#
ret = POpen (inHis, READWRITE, err)
ret = Obit.HistoryEdit(inHis.me, startr, endr, err.me)
OErr.printErr(err)
if err.isErr:
OErr.printErrMsg(err, "Error Editing History")
ret = PClose (inHis, err)
return ret
def Histo(self, blc, trc, nbin, range, err):
""" Computes histograms
self = object
blc = BLC (1-rel) in image
trc = TRC (1-rel) in image
nbin = number of bins (should be odd)
range = range in units of Image RMS about 0
err = Obit error/message stack
"""
################################################################
# Checks
if not PIsA(self):
raise TypeError("self MUST be a Python Obit PixHistFDR")
# make sure blc, trc are long
lblc = []
ltrc = []
for t in trc:
ltrc.append(int(t))
for t in blc:
lblc.append(int(t))
Obit.PixHistFDRHisto(self.me, lblc, ltrc, nbin, range, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error creating PixHistFDR histogram")
return
def AllDest (err, disk=None, Atype=" ", Aname=" ", Aclass=" ", Aseq=0):
""" Delete AIPS files matching a pattern
Strings use AIPS wild cards:
blank => any
'?' => one of any character
"*" => arbitrary string
disk = AIPS disk number, 0=>all
Atype = AIPS entry type, 'MA' or 'UV'; ' => all
Aname = desired AIPS name, using AIPS wildcards, None -> don't check
Aclass = desired AIPS class, using AIPS wildcards, None -> don't check
Aseq = desired AIPS sequence, 0=> any
"""
################################################################
global Adisk
if disk==None:
disk = Adisk
else:
if disk>0:
Adisk = disk
# NO Confirm
#prompt = "Do you really want to delete all AIPS "+Atype+" files on disk(s) "\
# +str(disk)+"\nwith names matching "+Aname+"."+Aclass+"."+str(Aseq)+ \
# " y/n "
#ans = raw_input(prompt)
#if ans.startswith('y'):
AIPSDir.PAllDest (disk, err, Atype=Atype, Aname=Aname, Aclass=Aclass,
Aseq=Aseq)
#else:
# print "Not confirmed"
OErr.printErrMsg(err, "Error with destroying AIPS enreies")
def PMakeImage (inUV, outImage, channel, doBeam, doWeight, err):
""" Grids UV, FFTs and makes corrections for the gridding convolution.
inUV = Input Python uv data. Should be in form of Stokes to be imaged
will all calibration and selection applied.
outImage = Python Image to be written. Must be previously instantiated.
Beam normalization factor is written to output Beam
infoList as SUMWTS
channel = Which frequency channel to image, 0->all.
doBeam = if TRUE also make beam. Will make the myBeam member of outImage.
If FALSE, and myGrid->BeamNorm 0.0 then reads SUMWTS value
from beam infolist
doWeigh = if TRUE Apply uniform weighting corrections to uvdata before imaging
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not UV.PIsA(inUV):
raise TypeError,"inUV MUST be a Python Obit UV"
if not Image.PIsA(outImage):
print "Actually ",outImage.__class__
raise TypeError,"outImage MUST be a Python Obit Image"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
Obit.ImageUtilMakeImage(inUV.me, outImage.me, channel, doBeam, doWeight, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error creating Image from UV data")
def PReimage (inCleanVis, uvdata, err):
"""
See if an image needs to be remade
See if an image needs to be remade because a source which exceeds
the flux threshold is not centered (as determined by moments)
on the reference pixel (within toler pixel).
A new (96x96) field is added centered on the offending source and a negative
clean window added to the position of the source in its original window.
Avoid duplicates of the same source and ensure that all occurances of this
source in any exant field has a negative clean window added.
Multiple centering sources per facet are allowed
A boolean entry "autoCenField" with value True is added to the info member of any
image members added to the mosaic member.
* inCleanVis = Python CleanVis object
* uvdata = Python uv data from which image is made
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inCleanVis):
raise TypeError,"inCleanVis MUST be a Python ObitCleanVis"
if not UV.PIsA(uvdata):
raise TypeError,"uvData MUST be a Python Obit UV"
#
out = Obit.CleanVisReimage(inCleanVis.me, uvdata.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error in Reimage")
return out
def PPBImage (pntImage, outImage, err,
minGain=0.1, outPlane=[1,1,1,1,1], antSize=25.0):
""" Calculate an image with a primary beam pattern
Make an image of the antenna primary beam pattern based on the pointing
position in an image.
pntImage = Python Image giving pointing position (ObsRA, ObsDec)
outImage = Python Image to be written. Must be previously instantiated.
err = Python Obit Error/message stack
minGain = minimum allowed gain (lower values blanked).
outPlane = 5 element int array with 1, rel. plane number [1,1,1,1,1]
giving location of plane to be written
antSize = Antenna diameter assumed, default 25m
"""
################################################################
# Checks
if not Image.PIsA(pntImage):
print "Actually ",pntImage.__class__
raise TypeError,"pntImage MUST be a Python Obit Image"
if not Image.PIsA(outImage):
print "Actually ",outImage.__class__
raise TypeError,"outImage MUST be a Python Obit Image"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
if len(outPlane) != 5:
raise TypeError,"outPlane must have 5 elements"
#
Obit.ImageUtilPBImage(outImage.me, outImage.me,
outPlane, antSize, minGain, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error with primary beam image")
def PInterpolateImage (inImage, outImage, err,
inPlane=[1,1,1,1,1], outPlane=[1,1,1,1,1], hwidth=2):
""" Interpolates one image onto another's grid.
Pixels in outImage are interpolated from inImage
inImage = Input Python Image.
outImage = Python Image to be written. Must be previously instantiated.
err = Python Obit Error/message stack
inPlane = 5 element int array with 1, rel. plane number [1,1,1,1,1]
giving location of plane to be interpolated
outPlane = 5 element int array with 1, rel. plane number [1,1,1,1,1]
giving location of plane to be written
hwidth = half width of interpolation kernal [1-4] default 2
"""
################################################################
# Checks
if not Image.PIsA(inImage):
raise TypeError,"inImage MUST be a Python Obit Image"
if not Image.PIsA(outImage):
print "Actually ",outImage.__class__
raise TypeError,"outImage MUST be a Python Obit Image"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
if len(inPlane) != 5:
raise TypeError,"inPlane must have 5 elements"
if len(outPlane) != 5:
raise TypeError,"outPlane must have 5 elements"
#
Obit.ImageUtilInterpolateImage(inImage.me, outImage.me,
inPlane, outPlane, hwidth, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error interpolating Image")
def GetFreqArr(inUV, err, inc = 1):
"""
Get Array of channel frequencies in data
Return list of channel Frequencies (Hz)
* inUV = Obit UV data with tables
* err = Python Obit Error/message stack
* inc = increment in channel
"""
################################################################
# Checks
if not UV.PIsA(inUV):
print("Actually ",inUV.__class__)
raise TypeError("inUV MUST be a Python Obit UV")
d = inUV.Desc.Dict # UV data descriptor dictionary
refFreq = d["crval"][ d["jlocf"]] # reference frequency
nchan = d["inaxes"][ d["jlocf"]] # Number of channels per IF
nif = d["inaxes"][ d["jlocif"]] # Number of IFs
chwid = abs(d["cdelt"][ d["jlocf"]]) # channel width from header
fqtab = inUV.NewTable(Table.READONLY,"AIPS FQ",1,err)
fqtab.Open(Table.READONLY,err)
fqrow = fqtab.ReadRow(1, err) # Only bother with first
OErr.printErrMsg(err) # catch table errors
IFfreq = fqrow['IF FREQ'] # IF offset
ChWidth = fqrow['CH WIDTH'] # IF channel width
sideband = fqrow['SIDEBAND'] # IF sizeband, 1=USB, -1=LSB
freqs = []
for iif in range(0,nif):
for ifq in range(0,nchan,inc):
frq = refFreq + IFfreq[iif] + sideband[iif] * ifq * min (chwid, ChWidth[iif])
freqs.append(frq)
# End loops
return freqs
def PInfo(disk, user, cno, err):
"""
Get information for a AIPS catalog slot number
Returned string s:
====== =============
Aname s[0:12]
Aclass s[13:19]
Aseq int(s[20:25])
Atype s[26:28]
====== =============
returns string describing entry, None=>empty
* disk = AIPS disk number
* user = AIPS user number
* cno = AIPS catalog slot to deassign
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
ret = Obit.AIPSDirInfo(disk, user, cno, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error reading AIPS catalog header")
return ret
def CreateSU(inUV, outUV, err):
"""
Write data in meta to SU table
* inUV = list of input Obit UV objects (freq order)
* outUV = output Obit UV object, defined but not instantiated
* err = Obit error/message stack
"""
###############################################################
# Create SU table
idd = inUV.Desc.Dict # Info from input header
nIF = idd["inaxes"][idd["jlocif"]] # how many IFs
sutab = outUV.NewTable(Table.READWRITE, "AIPS SU", 1, err, numIF=nIF)
if err.isErr:
OErr.printErrMsg(err, "Error with SU table")
sutab.Open(Table.READWRITE, err)
if err.isErr:
OErr.printErrMsg(err, "Error opening SU table")
# Update header
sutab.keys['RefDate'] = idd["obsdat"]
sutab.keys['Freq'] = idd["crval"][idd["jlocf"]]
Table.PDirty(sutab) # Force update
row = sutab.ReadRow(1, err)
if err.isErr:
OErr.printErrMsg(err, "Error reading SU table")
irow = 1
IFZero = [] # Array of NIF zeroes
for i in range(0, nIF):
IFZero.append(0.0)
row['ID. NO.'] = [1]
row['SOURCE'] = [idd["object"]]
row['RAEPO'] = [idd["crval"][idd["jlocr"]]]
row['DECEPO'] = [idd["crval"][idd["jlocd"]]]
row['RAOBS'] = [idd["obsra"]]
row['DECOBS'] = [idd["obsdec"]]
row['EPOCH'] = [idd["equinox"]]
row['RAAPP'] = [0.0]
row['DECAPP'] = [0.0]
row['BANDWIDTH'] = [idd["cdelt"][idd["jlocf"]]]
row['Table name'] = 'AIPS SU'
row['IFLUX'] = IFZero
row['QFLUX'] = IFZero
row['UFLUX'] = IFZero
row['VFLUX'] = IFZero
row['FREQOFF'] = IFZero
row['RESTFREQ'] = IFZero
row['LSRVEL'] = IFZero
row['CALCODE'] = [' ']
row['NumFields'] = 22
row['QUAL'] = [0]
row['PMRA'] = [0.0]
row['PMDEC'] = [0.0]
row['_status'] = [1]
sutab.WriteRow(irow, row, err)
if err.isErr:
OErr.printErrMsg(err, "Error writing SU table")
sutab.Close(err)
if err.isErr:
OErr.printErrMsg(err, "Error closing SU table")
def PSubArr(inFA, blc, trc, err):
"""
Return a slice of an FArray
returns Slice in FArray
* inFA = input Python FArray
* blc = array giving (1-rel) lower index of first cell to copy, e.g. [1,1]
* trc = array giving (1-rel) highest index of first cell to copy
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inFA):
print("Actually ", inFA.__class__)
raise TypeError("inFA MUST be a Python Obit FArray")
lblc = []
ltrc = [] # Make sure blc,trc are long
for b in blc:
lblc.append(int(b))
for b in trc:
ltrc.append(int(b))
outFA = FArray("None")
outFA.me = Obit.FArraySubArr(inFA.me, lblc, ltrc, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error slicing FArray")
return outFA
def POverlap (inID1, inID2, err):
"""
Determine if there is any overlap between images
Compares ImageDesc objects to see if the associated
images overlap on the sky.
Returns True if so sles False
* inID1 = First Python Obit ImageDesc for test
* inID2 = Second Python Obit ImageDesc for test
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inID1):
raise TypeError,"inID1 MUST be a Python Obit ImageDesc"
if not PIsA(inID2):
raise TypeError,"inID2 MUST be a Python Obit ImageDesc"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
res = Obit.ImageDescOverlap (inID1.me, inID2.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error determining overlap")
return res!=0
def PMakeImage(inUV, outImage, channel, doBeam, doWeight, err):
"""
Grids UV, FFTs and makes corrections for the gridding convolution.
* inUV = Input Python uv data. Should be in form of Stokes to be imaged
will all calibration and selection applied.
* outImage = Python Image to be written. Must be previously instantiated.
Beam normalization factor is written to output Beam infoList as SUMWTS
* channel = Which frequency channel to image, 0->all.
* doBeam = if TRUE also make beam. Will make the myBeam member of outImage.
If FALSE, and myGrid->BeamNorm 0.0 then reads SUMWTS value from beam infolist
* doWeigh = if TRUE Apply uniform weighting corrections to uvdata before imaging
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not UV.PIsA(inUV):
raise TypeError("inUV MUST be a Python Obit UV")
if not Image.PIsA(outImage):
print("Actually ", outImage.__class__)
raise TypeError("outImage MUST be a Python Obit Image")
if not err.IsA():
raise TypeError("err MUST be an OErr")
#
Obit.ImageUtilMakeImage(inUV.me, outImage.me, channel, doBeam, doWeight,
err.me)
if err.isErr:
OErr.printErrMsg(err, "Error creating Image from UV data")
def ZapTable(self, tabType, tabVer, err):
"""
Destroy specified table
Returns 0 on success
* self = Python OData object
* tabType = Table type, e.g. "AIPS CC"
* tabVer = table version, integer
* err = Python Obit Error/message stack
"""
inOData = self
# Checks
if not self.ODataIsA():
raise TypeError, "input MUST be a Python Obit OData"
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
# Open/Close to (re)Read header to be sure it's up to date
inOData.Open(READONLY, err)
inOData.Close(err)
# delete table
ret = Obit.ODataZapTable(inOData.cast(myClass), tabType, tabVer,
err.me)
if err.isErr:
OErr.printErrMsg(err, "Error Zapping OData data Table")
# Update header
inOData.UpdateTables(err)
return ret
def PTableCCFixTSpec (inImage, inCCVer, refFreq, nTerm, terms, \
err, startCC=1, endCC=0, ):
""" Convert an (tabulated) TSpec CC Table to spectral parameter table
Output CC Table will have fitted spectra rather than tabulated spectra.
Tabulated spectrum fitted with spectrum weighting by primary beam
inImage input Obit Python Image 1
Must have freq axis type = "SPECLNMF"
inCCVer CCTable to modify, 0=> highest
refFreq Reference frequency for spectrum (Hz)
nTerm Number of terms in spectrum
err Python Obit Error/message stack
startCC First 1-rel component to consider
endCC Last 1-rel component to consider, 0=> all
"""
################################################################
# Checks
if not Image.PIsA(inImage):
raise TypeError("inImage MUST be a Python Obit Image")
if not err.IsA():
raise TypeError("err MUST be an OErr")
#
Obit.TableCCUtilFixTSpec(inImage.me, inCCVer, refFreq, nTerm, terms, \
startCC, endCC, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error Modifying CC Table")
def GetTargetPos(OTF, Target, err):
""" Get target position from OTFTarget table
return [raepo, decepo] in deg
Loop through target table on OTF looking for Target and return position
OTF = OTF data file to check
Target = Name of target e.g. "MARS"
"""
################################################################
# Checks
if not OTF.OTFIsA():
raise TypeError, "OTF MUST be a Python Obit OTF"
if type(Target) != str:
raise TypeError, "Target MUST be a string"
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
tarTab = OTF.NewTable(Table.READONLY, "OTFTarget", 1, err)
tarTab.Open(Table.READONLY, err)
OErr.printErrMsg(err, "Error with OTFTarget table")
norow = tarTab.Desc.Dict["nrow"]
for irow in range(1, norow + 1):
row = tarTab.ReadRow(irow, err)
if row["TARGET"][0].strip() == Target.strip():
out = [row["RAEPO"][0], row["DECEPO"][0]]
tarTab.Close(err)
return out
tarTab.Close(err)
# Didn't find it if it gets here
OErr.printErrMsg(err, "Error getting Target")
raise RuntimeError, "Failed to find target " + Target + " in OTFTarget on " + OTF.GetName(
)
return [None, None]
def PGetPos (inID, inPixel, err):
"""
Return position of pixel inPixel in inID
returns array of 2 floats giving (RA, Dec) in deg of pixel inPixel
* inID = Python Obit ImageDesc for input
* inPixel = array of floats giving position in image described by inID
only first 2 used.
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inID):
raise TypeError,"inID MUST be a Python Obit ImageDesc"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
if inPixel[0].__class__ != float:
print "class is" , inPixel[0].__class__
raise TypeError,"inPixel MUST be float"
if len(inPixel) < 2:
raise RuntimeError,"inPixel has fewer then 2 entries"
#
outTmp = Obit.ImageDescGetPos (inID.me, inPixel, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error converting pixel location to position")
out = outTmp[0:2]
return out
def UpdateDescriptor(outUV, meta, err):
"""
Update information in data descriptor
NB: Cannot change geometry of visibilities
* outUV = Obit UV object
* meta = dict with data meta data
* err = Python Obit Error/message stack to init
"""
################################################################
chinc = meta["spw"][0][2] # Frequency increment
reffreq = meta["spw"][0][1] # reference frequency
nchan = meta["spw"][0][0] # number of channels
nif = len(meta["spw"]) # Number of IFs
nstok = meta["nstokes"] # Number of Stokes products
desc = outUV.Desc.Dict
outUV.Desc.Dict = desc
desc['obsdat'] = meta["obsdate"]
desc['observer'] = meta["observer"]
desc['JDObs'] = UVDesc.PDate2JD(meta["obsdate"])
desc['naxis'] = 6
desc['inaxes'] = [3, nstok, nchan, nif, 1, 1, 0]
desc['cdelt'] = [1.0, -1.0, chinc, 1.0, 0.0, 0.0, 0.0]
desc['crval'] = [1.0, -5.0, reffreq, 1.0, 0.0, 0.0, 0.0]
desc['crota'] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
outUV.Desc.Dict = desc
outUV.UpdateDesc(err)
if err.isErr:
OErr.printErrMsg(err, "Error updating UV descriptor")
def VLAClearCal(uv, err, doGain=True, doBP=False, doFlag=False):
""" Clear previous calibration
Delete all SN tables, all CL but CL 1
uv = UV data object to clear
err = Obit error/message stack
doGain = If True, delete SN and CL tables
doBP = If True, delete BP tables
doFlag = If True, delete FG tables
"""
################################################################
# Gain tables
if doGain:
uv.ZapTable("AIPS SN", -1, err)
ver = uv.GetHighVer("AIPS CL")
while (ver > 1):
uv.ZapTable('AIPS CL', ver, err)
ver = ver - 1
# Bandpass
if doBP:
uv.ZapTable("AIPS BP", -1, err)
# Flag tables
if doFlag:
uv.ZapTable("AIPS FG", -1, err)
OErr.printErrMsg(err, "VLAClearCal: Error reseting calibration")
def PUVImage(InImager,
err,
field=0,
doWeight=False,
doBeam=True,
doFlatten=False):
""" Form image optionally doing the calibration/weighting and flatten stages
UV Data is imaged to form dirty beam. Control parameters are those on UV data
passed at UVImager creation.
InImager = UVImager object
field = field number (1-rel) to image, 0=> all
err = Python Obit Error/message stack
doWeight = Do weighting (Uniform, tapering,...) before imaging
If True then input data is modified.
doBeam = Make Beam before image, must be done once.
doFlatten = Flatten image mosaic onto single image
"""
################################################################
#
# Checks
if not PIsA(InImager):
print "input class actually ", InImager.__class__
raise TypeError, 'PUVImage: Bad input UVImager'
#
Obit.UVImagerImage(InImager.me, field, doWeight, doBeam, doFlatten, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error Imaging data")
def _verify(self, desc):
# Initialize Obit if needed
if not OSystem.PIsInit() and desc:
AIPSdirs = desc["dirs"]
userno = desc["userno"]
popsno = 1
if not self.err:
self.err=OErr.OErr()
self.ObitSys=OSystem.OSystem ("", popsno, userno, \
len(AIPSdirs), AIPSdirs, \
0, [], True, False, self.err)
OErr.printErrMsg(self.err, "Error with Obit startup")
self.doInit = True
else:
self.doInit = False
try:
data = self._init(desc)
except OErr.OErr as err:
print(err)
#OErr.printErrMsg(err, "AIPSData._verify")
if self.doInit: # Initialized Obit?
OSystem.Shutdown(self.ObitSys)
raise RuntimeError("Cannot open data set %s" % desc['name'])
#OErr.printErrMsg(self.err, "AIPSData._verify")
return data
def PWebFetch(url, args, outfile, err):
"""
Generic Fetch a web product
Sends a http post request to url and sames response to outfile
Throws exception on error
* url = where the request to be sent,
e.g."https://www.cv.nrao.edu/cgi-bin/postage.pl"
* args = dict or arguments, e.g. {"arg1":"arg1"}
* outfile = Name of the output file, absolute path or relative to CWD
None => use name from server
* err = Python Obit Error/message stack
"""
################################################################
# Package parameters
encoded_args = six.moves.urllib.parse.urlencode(args)
NVSShost = "https://www.cv.nrao.edu/cgi-bin/postage.pl"
# fetch
try:
request = six.moves.urllib.request.Request(url)
response = six.moves.urllib.request.urlopen(request, encoded_args)
data = response.read()
except Exception as exception:
print(exception)
OErr.PLog(err, OErr.Error, "Request from server failed")
OErr.printErrMsg(err)
if outfile == None: # Name from server?
outfile = os.path.basename(response.headers['URI'])
fd = open(outfile, "wb")
fd.write(data)
fd.close()
# Info
print("Response code =", response.code, response.msg)
print("Response type =", response.headers["Content-Type"])
def PSetDir(disk, newName, err, URL=None):
""" Set the directory name for a given AIPS directory
returns disk number actually used
disk = AIPS disk number, <=0 => assign
newName = new directory path
err = Python Obit Error/message stack
URL = URL if on a remote host (Only if using OTObit/ParselTongue)
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
retDisk = Obit.AIPSSetDirname(disk, newName, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error setting AIPS directory name")
AIPSdisks.append(newName)
nAIPS = len(AIPSdisks)
if (disk<=0):
try:
AIPS.AIPS.disks.append(AIPS.AIPSDisk(URL, retDisk, newName))
except:
pass
else:
pass
return retDisk;
def PSelInc(inFA, outFA, blc, trc, inc, err):
"""
Select elements in an FArray by increment
* inFA = input Python FArray
* outFA= output Python FArray
* blc = array giving (1-rel) lower index of first cell to copy, e.g. [1,1]
* trc = array giving (1-rel) highest index of first cell to copy
* inc = increment on each axis
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inFA):
print("Actually ", inFA.__class__)
raise TypeError("inFA MUST be a Python Obit FArray")
if not PIsA(outFA):
print("Actually ", outFA.__class__)
raise TypeError("outFA MUST be a Python Obit FArray")
lblc = []
ltrc = []
linc = [] # Make sure blc,trc,inc are long
for b in blc:
lblc.append(int(b))
for b in trc:
ltrc.append(int(b))
for b in inc:
ltrc.append(int(b))
Obit.FArraySelInc(inFA.me, outFA.me, lblc, ltrc, linc, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error selecting FArray")
return
def PAllDest(disk, err, Atype=" ", Aname=None, Aclass=None, Aseq=0):
"""
Delete selected AIPS catalog entries
Entries can be selected using Atype, Aname, Aclass, Aseq,
using AIPS wildcards
A "?" matches one of any character, "*" matches any string
all blanks matches anything
* disk = AIPS disk number, 0=>all
* err = Python Obit Error/message stack
* type = optional file type
* Aname = desired name, using AIPS wildcards, None -> don't check
* Aclass = desired class, using AIPS wildcards, None -> don't check
* Aseq = desired sequence, 0=> any
* first = optional first slot number (1-rel)
* last = optional last slot number
* giveList = If true, return list of CNOs matching
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
if (disk < 0) or (disk > (len(AIPS.AIPS.disks) + 1)):
raise RuntimeError, "Disk " + str(disk) + " out of range"
# disks
if disk > 0:
disks = [disk]
else:
disks = range(1, len(AIPS.AIPS.disks))
user = OSystem.PGetAIPSuser()
# loop over disks
for dsk in disks:
ncno = PNumber(dsk, user, err)
OErr.printErrMsg(err, "Error getting number of cnos")
for cno in range(1, ncno):
line = PInfo(dsk, user, cno, err)
OErr.printErrMsg(err, "Error reading entry")
if WantDir(line, type=Atype, Aname=Aname, Aclass=Aclass,
Aseq=Aseq):
# parse directory string
Tname = line[0:12]
Tclass = line[13:19]
Tseq = int(line[20:25])
Ttype = line[26:28]
z = None
if Ttype == 'MA':
z = Image.newPAImage("Zap image", Tname, Tclass, dsk, Tseq, True, err, \
verbose=False)
print "Zap AIPS Image", Tname, Tclass, dsk, Tseq
elif Ttype == 'UV':
z = UV.newPAUV("Zap UV data", Tname, Tclass, dsk, Tseq, True, err, \
verbose=False)
print "Zap AIPS UV", Tname, Tclass, dsk, Tseq
# Delete entry
if z:
z.Zap(err)
del z
def CopyTables(self, outOData, exclude, include, err):
"""
Copy Tables from one OData to another
* self = Python OData object
* outOData = Output Python OData object, must be defined
* exclude = list of table types to exclude (list of strings)
has priority
* include = list of table types to include (list of strings)
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not self.ODataIsA():
raise TypeError, "self MUST be a Python Obit OData"
if not outOData.ODataIsA():
raise TypeError, "outOData MUST be a Python Obit OData"
if not OErr.OErrIsA(err):
raise TypeError, "err MUST be an OErr"
#
ret = Obit.ODataCopyTables (self.cast(myClass), outOData.cast(myClass), \
exclude, include, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error copying Tables")
return ret
def PGetPixel (inID, inPos, err):
"""
Return pixel location in inID corresponding position inPos
returns array of 2 floats giving pixel position in outID.
* inID = Python Obit ImageDesc for input
* inPos = array of floats (RA, dec) in deg
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inID):
raise TypeError,"inID MUST be a Python Obit ImageDesc"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
if inPos[0].__class__ != float:
print "class is" , inPos[0].__class__
raise TypeError,"inPos MUST be float"
if len(inPos) < 2:
raise RuntimeError,"inPos has fewer then 2 entries"
#
outTmp = Obit.ImageDescGetPixel (inID.me, inPos, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error determining pixel")
out = outTmp[0:2]
return out
def PAllDest(disk, err, Atype = " ", Aname=None, Aclass=None, Aseq=0):
""" Delete selected AIPS catalog entries
Entries can be selected using Atype, Aname, Aclass, Aseq,
using AIPS wildcards
A "?" matches one of any character, "*" matches any string
all blanks matches anything
disk = AIPS disk number, 0=>all
err = Python Obit Error/message stack
type = optional file type
Aname = desired name, using AIPS wildcards, None -> don't check
Aclass = desired class, using AIPS wildcards, None -> don't check
Aseq = desired sequence, 0=> any
first = optional first slot number (1-rel)
last = optional last slot number
giveList = If true, return list of CNOs matching
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
if (disk<0) or (disk>(len(AIPS.AIPS.disks)+1)):
raise RuntimeError,"Disk "+str(disk)+" out of range"
# disks
if disk>0:
disks=[disk]
else:
disks= range(1,len(AIPS.AIPS.disks))
user = OSystem.PGetAIPSuser()
# loop over disks
for dsk in disks:
ncno = PNumber (dsk, user, err)
OErr.printErrMsg(err, "Error getting number of cnos")
for cno in range(1, ncno):
line=PInfo(dsk, user, cno, err);
OErr.printErrMsg(err, "Error reading entry")
if WantDir(line, type=Atype, Aname=Aname, Aclass=Aclass,
Aseq=Aseq):
# parse directory string
Tname = line[0:12]
Tclass = line[13:19]
Tseq = int(line[20:25])
Ttype = line[26:28]
z = None
if Ttype == 'MA':
z = Image.newPAImage("Zap image", Tname, Tclass, dsk, Tseq, True, err, \
verbose=False)
print "Zap AIPS Image",Tname, Tclass, dsk, Tseq
elif Ttype == 'UV':
z = UV.newPAUV("Zap UV data", Tname, Tclass, dsk, Tseq, True, err, \
verbose=False)
print "Zap AIPS UV",Tname, Tclass, dsk, Tseq
# Delete entry
if z:
z.Zap(err)
del z
def PFit (inImageFit, err, input=FitInput):
""" Fit a model to an image
Resultant model left in FitRegion reg
inImageFit = Python ImageFit object
image = ObitImage to be fitted
reg = Fit region defining what is to be fitted and initial guess
err = Python Obit Error/message stack
input = input parameter dictionary
Input dictionary entries:
fitImage = Image to be fitted
fitRegion = FitRegion to be fitted
MaxIter int Maximum number of iterations [def. 10 per fitted parameter]
prtLv int Message level, 0=>none [def 0]
PosGuard float Distance (cells) from edge to allow center [def no bound]
FluxLow float Lower bounds on Flux density [def no bound]
GMajUp float Major axis upper bound (cells) [def no bound]
GMajLow float Major axis lower bound (cells) [def no bound]
GMinUp float Minor axis upper bound (cells) [def no bound]
GMinLow float Minor axis lower bound (cells) [def no bound]
"""
################################################################
# Get input parameters
fitImage = input["fitImage"]
fitRegion = input["fitRegion"]
# Checks
if not PIsA(inImageFit):
raise TypeError,"inImageFit MUST be a Python Obit ImageFit"
if not Image.PIsA(fitImage):
raise TypeError,"fitImage MUST be a Python Obit Image"
if not FitRegion.PIsA(fitRegion):
raise TypeError,"fitRegion MUST be a Python Obit FitRegion"
#
dim = [1,1,1,1,1]
#
# Set control values on ImageFit
inInfo = PGetList(inImageFit) #
InfoList.PAlwaysPutInt (inInfo, "MaxIter", dim, [input["MaxIter"]])
InfoList.PAlwaysPutInt (inInfo, "prtLv", dim, [input["prtLv"]])
InfoList.PAlwaysPutDouble (inInfo, "PosGuard", dim, [input["PosGuard"]])
InfoList.PAlwaysPutDouble (inInfo, "FluxLow", dim, [input["FluxLow"]])
InfoList.PAlwaysPutDouble (inInfo, "GMajUp", dim, [input["GMajUp"]])
InfoList.PAlwaysPutDouble (inInfo, "GMajLow", dim, [input["GMajLow"]])
InfoList.PAlwaysPutDouble (inInfo, "GMinUp", dim, [input["GMinUp"]])
InfoList.PAlwaysPutDouble (inInfo, "GMinLow", dim, [input["GMinLow"]])
#
# Do operation
sm = inImageFit.cast(myClass) # cast pointer
ret = Obit.ImageFitFit(sm, fitImage.me, fitRegion.me, err.me)
if ret==0:
print "Fit converged"
else:
print "Fit hit iteration limit"
if err.isErr:
OErr.printErrMsg(err, "Error Fitting model")
def AUcat(disk=Adisk, first=1, last=1000):
""" Catalog listing of AIPS UV data files on disk disk
disk = AIPS disk number to list
first = lowest slot number to list
last = highest slot number to list
"""
################################################################
Adisk = disk
AIPSDir.PListDir(disk, err, type=AIPSDir.UVType, first=first, last=last)
OErr.printErrMsg(err, "Error with AIPS catalog")
def Acat(disk=Adisk, first=1, last=1000):
""" Catalog listing of AIPS files on disk disk
The class remembers the last disk accessed
disk = AIPS disk number to list
first = lowest slot number to list
last =highest slot number to list
"""
################################################################
Adisk = disk
AIPSDir.PListDir(disk, err, first=first, last=last)
OErr.printErrMsg(err, "Error with AIPS catalog")
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 PZap (inHis, err):
""" Destroy the persistent form of a History
inHis = input Python Obit History
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inHis):
raise TypeError,"inHis MUST be a History"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
Obit.HistoryZap (inHis.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error deleting History")
def PNumber(disk, user, err):
""" Return highest current allowed AIPS catalog Slot number
disk = AIPS disk number
user = AIPS user number
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
ret = Obit.AIPSDirNumber(disk, user, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error obtaining highest AIPS catalog number")
return ret
def PRestore (clean, err):
""" Restore subtracted CLEAN components to residual image
clean = Clean object containing mosaic
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(clean):
raise TypeError,"mosaic MUST be a Python Obit CleanImage"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
Obit.CleanImageRestore(clean.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error defining window")
def PGetMosaic (InImager, err):
""" Return the member ImageMosaic
returns ImageMosaic
InImager = Python ImageMosaic object
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(InImager):
raise TypeError,"InImager MUST be a Python Obit UVImager"
#
out = ImageMosaic.ImageMosaic("None", 1)
out.me = Obit.UVImagerGetMosaic(InImager.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error obtaining Mosaic member")
return out
def PCopy (inFA, err):
""" Make copy an FArray
returns copy
inFA = input Python FArray
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inFA):
print "Actually ",inFA.__class__
raise TypeError,"inFA MUST be a Python Obit FArray"
outFA = FArray("None")
outFA.me = Obit.FArrayCopy (inFA.me, outFA.me, err.me);
if err.isErr:
OErr.printErrMsg(err, "Error copying FArray")
return outFA
def PClone (inFA, err):
""" Make copy the structure of an FArray
Zero fill and return FArray with same structure as in
inFA = input Python FArray
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inFA):
print "Actually ",inFA.__class__
raise TypeError,"inFA MUST be a Python Obit FArray"
outFA = FArray("Clone")
Obit.FArrayClone (inFA.me, outFA.me, err.me);
if err.isErr:
OErr.printErrMsg(err, "Error zero cloning FArray")
return outFA
def PRemove(disk, user, cno, err):
""" Deallocate AIPS catalog slot number
disk = AIPS disk number
user = AIPS user number
cno = AIPS catalog slot to deassign
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
ret = Obit.AIPSDirRemoveEntry(disk, user, cno, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error removing AIPS catalog entry")
return ret
def PDump(infile, list, err):
""" Dump list to text file
Dump parameter format text file and copy to list
returns 0 on success, else 1
outfile = Name of the output text file to write
list = ObitInfoList to dump
err = ObitErr for reporting errors.
"""
################################################################
# Checks
if not InfoList.PIsA(list):
raise TypeError,"list MUST be a Python Obit InfoList"
ret = Obit.Dump(infile, list.me, err.me)
if ret or err.isErr:
OErr.printErrMsg(err, "Error Dumping to "+infile)
return ret
def PClose (inHis, err):
""" Close History
return 0 on success, else failure
inHis = input Python History
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inHis):
raise TypeError,"inHis MUST be a History"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
ret = Obit.HistoryClose(inHis.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error closing History")
return ret
def PUVFlatten (InImager, err):
""" Flatten ImageMosaic member
The images of the mosaic member are flattened to a single image.
This operation is optionally done in PUVImage.
InImager = UVImager object
err = Python Obit Error/message stack
"""
################################################################
#
# Checks
if not PIsA(InImager):
raise TypeError, 'PUVFlatten : Bad input UVImager'
#
Obit.UVImagerFlatten (InImager.me, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error flattening mosaic")
def PTimeStamp (inHis, label, err):
""" Write timestamp and label to History
return 0 on success, else failure
inHis = input Python History
label = character string for label
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inHis):
raise TypeError,"inHis MUST be a History"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
ret = Obit.HistoryTimeStamp(inHis.me, label, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error writing History time stamp")
def PCompressCC (inSkyModel, err):
""" Compress CC tables
Compresses CC tables on all Images in mosaic
inSkyModel = Python SkyModel object to compress
err = Python Obit Error/message stack
"""
################################################################
# Checks
if not PIsA(inSkyModel):
raise TypeError,"inSkyModel MUST be a Python Obit SkyModel"
if not OErr.OErrIsA(err):
raise TypeError,"err MUST be an OErr"
#
smi = inSkyModel.cast(myClass) # cast pointer
Obit.SkyModelCompressCC (smi, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error copying SkyModel")
def PAddWindow (inCleanImage, field, window, err):
""" Add a window to a field to be CLEANed
inCleanImage = Python CleanImage object
field = Which field (1-rel)is the window in?
window = set of 4 integers:
if window[0]<0 box is round and
window[1]=radius, [2,3] = center
else rectangular and
blc=(window[0],window[1]), trc= blc=(window[2],window[3])
"""
################################################################
# Checks
if not PIsA(inCleanImage):
raise TypeError,"inCleanImage MUST be a Python ObitCleanImage"
#
Obit.CleanImageAddWindow(inCleanImage.me, field, window, err.me)
if err.isErr:
OErr.printErrMsg(err, "Error adding window")