def PGetPoln(VLtab, imQ, imU, err, RMSsize=100):
"""
Get polarization info for VL table
VLtab input VL table
imQ Q pol Image
imU U pol Image, same geometry as Q
err Obit Err/message object
RMSsize halfwidth in pixels of RMS box
"""
dQ = imQ.Desc
dU = imU.Desc
if not ImageDesc.PCheckCompat(dQ, dU):
OErr.printErrMsg(err, "Error: Q,U images are incompatible")
nx = dQ.Dict['inaxes'][0]
ny = dQ.Dict['inaxes'][1]
size = min(RMSsize, nx / 2, ny / 2) # Actual RMS box size
fblank = FArray.fblank
# Get Q, U images
pixQ = Image.PReadPlane(imQ, err)
pixU = Image.PReadPlane(imU, err)
if err.isErr:
OErr.printErrMsg(err, "Error Reading Q,U images")
# Make interpolators
fiQ = FInterpolate.FInterpolate('Q', pixQ, dQ, 2)
fiU = FInterpolate.FInterpolate('U', pixU, dU, 2)
# Open table
VLtab.Open(Table.READWRITE, err)
if err.isErr:
OErr.printErrMsg(err, "Error Opening table")
nrow = VLtab.Desc.Dict['nrow']
for irow in range(1, nrow + 1):
row = VLtab.ReadRow(irow, err)
pos = [row['RA(2000)'][0], row['DEC(2000)'][0]]
# pixel
pixel = ImageDesc.PGetPixel(dQ, pos, err)
# In image?
if (pixel[0] < 2.0) or (pixel[1] < 2.0) or (pixel[0] > nx - 2) or (
pixel[1] > ny - 2):
continue
# Fluxes
qval = FInterpolate.PPosition(fiQ, pos, err)
uval = FInterpolate.PPosition(fiU, pos, err)
# Valid?
if (qval == fblank) or (uval == fblank):
continue
row['Q CENTER'][0] = qval
row['U CENTER'][0] = uval
row['P FLUX'][0] = (qval * qval + uval * uval)**0.5
if err.isErr:
OErr.printErrMsg(err, "Error Interpolating")
# RMS box
blc = [int(pixel[0]) - RMSsize, int(pixel[1]) - RMSsize]
trc = [int(pixel[0]) + RMSsize, int(pixel[1]) + RMSsize]
if blc[0] < 0:
blc[0] = 0
trc[0] = min(2 * size, nx - 1)
if blc[1] < 0:
blc[1] = 0
trc[1] = min(2 * size, ny - 1)
if trc[0] > nx - 1:
d = trc[0] - nx
blc[0] = max(1, blc[0] - d)
trc[0] = nx - 1
if trc[1] > ny - 1:
d = trc[1] - ny
blc[1] = max(1, blc[1] - d)
trc[1] = ny - 1
# RMSes
box = FArray.PSubArr(pixQ, blc, trc, err)
rmsQ = box.RMS
del box
box = FArray.PSubArr(pixU, blc, trc, err)
rmsU = box.RMS
del box
row['POL RMS'][0] = 0.5 * (rmsQ + rmsU)
VLtab.WriteRow(irow, row, err)
if err.isErr:
OErr.printErrMsg(err, "Error Writing table")
# end loop over table
VLtab.Close(err)
del pixQ, pixU, fiQ, fiU
nterm = icube.Desc.List.Dict['NTERM'][2][0]
nspec = icube.Desc.List.Dict['NSPEC'][2][0]
freqs = []
for i in range(1, nspec + 1):
key = 'FREQ%4.4d' % i
freqs.append(1.0e-9 * icube.Desc.List.Dict[key][2][0]) # GHz
# end loop
# Interpolator
fi = FInterpolate.FInterpolate('FI', icube.FArray, icube.Desc, 2)
# Get pixel locations
pixels = []
vals = []
for s in srcpos:
pos = [ImageDesc.PHMS2RA(s[1]), ImageDesc.PDMS2Dec(s[2])]
pixel = ImageDesc.PGetPixel(icube.Desc, pos, err)
pixels.append(pixel)
vals.append(nspec * [fblank])
# end loop
OErr.printErrMsg(err, message='Finding positions')
# Loop over planes interpolating values
rms = []
for i in range(0, nspec):
# Read plane
plane = [i + nterm + 1, 1, 1, 1, 1]
Image.PGetPlane(icube, None, plane, err)
rms.append(icube.FArray.RMS) # Plane RMS
# Interpolate positions
for j in range(0, len(pixels)):
pixel = pixels[j]
numIF = x.Desc.Dict['inaxes'][3]
# Read input plane
x.GetPlane(None, iplane, err)
inArr = x.FArray
# Input pixels
ImageUtil.PGetXYPixels(x, outIm, XPixIm, YPixIm, err)
xpix = XPixIm.FArray
ypix = YPixIm.FArray
# Set interpolator to input image
FInterpolate.PSetDesc(fi, x.Desc)
FInterpolate.PReplace(fi, inArr)
# Interpolate
for ix in range(0, ncell):
for iy in range(0, ncell):
pos = [space * (ix - half), space * (iy - half)]
pix = ImageDesc.PGetPixel(x.Desc, pos, err)
val = FInterpolate.PPixel(fi, pix, err)
work.set(val, ix, iy)
# end interpolation loops
# Accumulate weight image, zero where image blanked
FArray.PFill(work2, weight[ires])
FArray.PBlank(work2, work, work2)
FArray.PDeblank(work2, 0.0) # Replace any blanking with 0.0
FArray.PAdd(accW, work2, accW)
# Image * wt
FArray.PDeblank(work, 0.0) # Replace any blanking with 0.0
FArray.PSMul(work, weight[ires])
# Accumulate image*wt
FArray.PAdd(accWI, work, accWI)
ires += 1
# Next resolution