def ok():
if not with_pg:
return True
pg.pgopen('/null')
self.ccd.plot(5,95)
pg.pgclos()
return True
def ok():
if not with_pg:
return True
pg.pgopen('/null')
self.ccd.plot(5, 95)
pg.pgclos()
return True
def closeplot():
"""
closeplot()
Close the currenly opened device, finalizing the plot.
"""
# Close plot
if ppgplot.pgqid()!=0:
ppgplot.pgclos()
else:
sys.stderr.write("Cannot close plot. No pgplot device open.\n")
raise "No open pgplot device"
def pgplot(slot, plotterHandle):
print "We are about to plot: %s"%(slot)
lightcurveView = ppgplot.pgopen('/xs')
xValues = slot.photometry.times
xValues = numpy.arange(0, len(xValues))
yValues = slot.getColumn("Counts")
ppgplot.pgenv(min(xValues), max(xValues), min(yValues), max(yValues), 0, 0)
ppgplot.pgask(False)
ppgplot.pgsci(2)
ppgplot.pgpt(xValues, yValues, 1)
ppgplot.pgclos()
return
def closeDev(devID='current'):
"""
DES: close selected device
INP: (int) device ID, 'all','current' (default)
"""
global CurrentDev, DevList
if devID in ['current', 'curren', 'curre', 'curr', 'cur']:
__MessHand.longinfo("closing the current device")
ppgplot.pgclos()
DevList.remove(CurrentDev)
if not DevList == []:
ppgplot.pgslct(DevList[0])
CurrentDev = ppgplot.pgqid() # store the actual deviceID
else:
CurrentDev = 0
elif devID in ['all']:
__MessHand.longinfo("closing all devices")
for device in DevList:
ppgplot.pgslct(device)
ppgplot.pgclos()
DevList = []
CurrentDev = 0
elif devID in DevList:
__MessHand.longinfo("closing device " + ` devID `)
ppgplot.pgslct(devID)
ppgplot.pgclos()
DevList.remove(devID)
if devID == CurrentDev and DevList != []:
ppgplot.pgslct(DevList[0])
CurrentDev = ppgplot.pgqid() # store the actual deviceID
else:
ppgplot.pgslct(CurrentDev)
else:
__MessHand.error("this is not an open device: " + ` devID `)
__queryDev()
def ok():
pg.pgopen('/null')
self.ccd.plot(5,95)
pg.pgclos()
return True
def main(options):
global keepPlotting
keepPlotting = True
debug = options.debug
inputMS = glob.glob(options.inms)
if inputMS == '':
print 'Error: You must specify a MS name.'
print ' Use "uvplot.py -h" to get help.'
return
if options.inms.endswith('/'):
options.inms = options.inms[:-1]
inputMSbasename = options.inms.split('/')[-1]
if inputMSbasename == '':
# The user has not specified the full path of the MS
inputMSbasename = options.inms
device = options.device
if device=='?':
ppgplot.pgldev()
return
xaxis = options.xaxis
if xaxis == 'ha':
print 'Adding derived columns to allow plotting hour angle...'
try:
pt.addDerivedMSCal(inputMS)
except:
print 'Failed, trying to remove and add columns...'
try:
pt.removeDerivedMSCal(inputMS)
pt.addDerivedMSCal(inputMS)
except:
print 'That failed too... plotting HA seems to not be possible.'
return
yaxis = options.yaxis
column = options.column
nx, ny = options.nxy.split(',')
axlimits = options.axlimits.split(',')
if len(axlimits) == 4:
xmin,xmax,ymin,ymax = axlimits
else:
print 'Error: You must specify four axis limits'
return
showFlags = options.flag
flagCol = options.colflag
showAutocorr = options.autocorr
showStats = options.statistics
timeslots = options.timeslots.split(',')
if len(timeslots) != 2:
print 'Error: Timeslots format is start,end'
return
for i in range(len(timeslots)): timeslots[i] = int(timeslots[i])
antToPlotSpl = options.antennas.split(',')
antToPlot = []
for i in range(len(antToPlotSpl)):
tmpspl = antToPlotSpl[i].split('..')
if len(tmpspl) == 1:
antToPlot.append(int(antToPlotSpl[i]))
elif len(tmpspl) == 2:
for j in range(int(tmpspl[0]),int(tmpspl[1])+1):
antToPlot.append(j)
else:
print 'Error: Could not understand antenna list.'
return
polarizations = options.polar.split(',')
for i in range(len(polarizations)):
polarizations[i] = int(polarizations[i])
convertStokes = options.stokes
operation = options.operation
if operation != '':
operation = int(operation)
if convertStokes:
print 'Error: Stokes conversion is not compatible with special operations'
return
channels = options.channels.split(',')
if len(channels) != 2:
print 'Error: Channels format is start,end'
return
for i in range(len(channels)): channels[i] = int(channels[i])
if channels[1] == -1:
channels[1] = None # last element even if there is only one
else:
channels[1] += 1
queryMode = options.query
doUnwrap = options.wrap
if not queryMode:
# open the graphics device, use the right number of panels
ppgplot.pgbeg(device, int(nx), int(ny))
# set the font size
ppgplot.pgsch(1.5)
ppgplot.pgvstd()
# open the main table and print some info about the MS
t = pt.table(inputMS, readonly=True, ack=False)
firstTime = t.query(sortlist='TIME',columns='TIME',limit=1).getcell("TIME", 0)
lastTime = t.query(sortlist='TIME',columns='TIME',offset=t.nrows()-1).getcell("TIME", 0)
intTime = t.getcell("INTERVAL", 0)
print 'Integration time:\t%f sec' % (intTime)
nTimeslots = (lastTime - firstTime) / intTime
if timeslots[1] == -1:
timeslots[1] = nTimeslots
else:
timeslots[1] += 1
print 'Number of timeslots:\t%d' % (nTimeslots)
# open the antenna and spectral window subtables
tant = pt.table(t.getkeyword('ANTENNA'), readonly=True, ack=False)
tsp = pt.table(t.getkeyword('SPECTRAL_WINDOW'), readonly=True, ack=False)
numChannels = len(tsp.getcell('CHAN_FREQ',0))
print 'Number of channels:\t%d' % (numChannels)
print 'Reference frequency:\t%5.2f MHz' % (tsp.getcell('REF_FREQUENCY',0)/1.e6)
# Station names
antList = tant.getcol('NAME')
if len(antToPlot)==1 and antToPlot[0]==-1:
antToPlot = range(len(antList))
print 'Station list (only starred stations will be plotted):'
for i in range(len(antList)):
star = ' '
if i in antToPlot: star = '*'
print '%s %2d\t%s' % (star, i, antList[i])
# Bail if we're in query mode
if queryMode:
return
# select by time from the beginning, and only use specified antennas
tsel = t.query('TIME >= %f AND TIME <= %f AND ANTENNA1 IN %s AND ANTENNA2 IN %s' % (firstTime+timeslots[0]*intTime,firstTime+timeslots[1]*intTime,str(antToPlot),str(antToPlot)))
# values to use for each polarization
plotColors = [1,2,3,4]
labXPositions = [0.35,0.45,0.55,0.65]
labYPositions = [1.0,1.0,1.0,1.0]
if convertStokes:
polLabels = ['I','Q','U','V']
else:
polLabels = ['XX','XY','YX','YY']
# define nicely written axis labels
axisLabels = {'time': 'Time',
'ha': 'Hour angle',
'chan': 'Channel',
'freq': 'Frequency [MHz]',
'amp': 'Visibility amplitude',
'real': 'Real part of visibility',
'imag': 'Imaginary part of visibility',
'phase': 'Visibility phase [radians]'}
# Now we loop through the baselines
ppgplot.pgpage()
for tpart in tsel.iter(["ANTENNA1","ANTENNA2"]):
if not keepPlotting: return
ant1 = tpart.getcell("ANTENNA1", 0)
ant2 = tpart.getcell("ANTENNA2", 0)
if ant1 not in antToPlot or ant2 not in antToPlot: continue
if ant1 == ant2:
if not showAutocorr:
continue
# Get the values to plot, strategy depends on axis type
if xaxis == 'time' or xaxis == 'ha':
xaxisvals = getXAxisVals(tpart, xaxis, channels)
yaxisvals = getYAxisVals(tpart, yaxis, column, operation, showFlags, flagCol, channels, doUnwrap, convertStokes)
else:
xaxisvals = getXAxisVals(tsp, xaxis, channels)
yaxisvals = getYAxisVals(tpart, yaxis, column, operation, showFlags, flagCol, channels, doUnwrap, convertStokes, xaxistype=1)
if xaxisvals == None: # This baseline must be empty, go to next one
print 'No good data on baseline %s - %s' % (antList[ant1],antList[ant2])
continue
if debug:
print xaxisvals.shape
print yaxisvals.shape
for r in range(len(xaxisvals)):
print '%s'%yaxisvals[r]
if len(xaxisvals) != len(yaxisvals): # something is wrong
print 'Error: X and Y axis types incompatible'
return
# Plot the data, each polarization in a different color
ppgplot.pgsci(1)
if xmin == '':
minx = xaxisvals.min()
else:
minx = float(xmin)
if xmax == '':
maxx = xaxisvals.max()
else:
maxx = float(xmax)
if ymin == '':
miny = yaxisvals.min()
if numpy.ma.getmaskarray(yaxisvals.min()):
print 'All data flagged on baseline %s - %s' % (antList[ant1],antList[ant2])
continue
else:
miny = float(ymin)
if ymax == '':
maxy = yaxisvals.max()
else:
maxy = float(ymax)
if minx == maxx:
minx -= 1.0
maxx += 1.0
else:
diffx = maxx - minx
minx -= 0.02*diffx
maxx += 0.02*diffx
if miny == maxy:
miny -= 1.0
maxy += 1.0
else:
diffy = maxy - miny
miny -= 0.02*diffy
maxy += 0.02*diffy
#ppgplot.pgpage()
ppgplot.pgswin(minx,maxx,miny,maxy)
if xaxis == 'time' or xaxis == 'ha':
ppgplot.pgtbox('ZHOBCNST',0.0,0,'BCNST',0.0,0)
else:
ppgplot.pgbox('BCNST',0.0,0,'BCNST',0.0,0)
#ppgplot.pglab(axisLabels[xaxis], axisLabels[yaxis], '%s - %s'%(antList[ant1],antList[ant2]))
#ppgplot.pgmtxt('T', 3.0, 0.5, 0.5, inputMSbasename)
ppgplot.pglab(axisLabels[xaxis], axisLabels[yaxis], inputMSbasename + '(' + getDataDescription(column) + '): %s - %s'%(antList[ant1],antList[ant2]))
if operation != 0:
# some operations is defined
if operation == 1:
label = 'XX-YY'
elif operation == 2:
label = 'XY.YX*'
else:
print 'Special operation not defined'
return
ppgplot.pgsci(plotColors[0])
tmpvals = yaxisvals
print 'Baseline',antList[ant1],'-',antList[ant2],': Plotting',len(tmpvals[~tmpvals.mask]),'points of ' + label
ppgplot.pgpt(xaxisvals[~tmpvals.mask], tmpvals[~tmpvals.mask], 1)
addInfo(showStats, tmpvals[~tmpvals.mask], label, labXPositions[1], labYPositions[1])
else:
for j in polarizations:
ppgplot.pgsci(plotColors[j])
tmpvals = yaxisvals[:,j]
if j == polarizations[0]:
print 'Baseline',antList[ant1],'-',antList[ant2],': Plotting',len(tmpvals[~tmpvals.mask]),'points per polarization'
ppgplot.pgpt(xaxisvals[~tmpvals.mask], tmpvals[~tmpvals.mask], 1)
addInfo(showStats, tmpvals[~tmpvals.mask], polLabels[j], labXPositions[j], labYPositions[j])
ppgplot.pgpage()
# Close the PGPLOT device
ppgplot.pgclos()
if xaxis=='ha':
print 'Removing derived columns...'
pt.removeDerivedMSCal(inputMS)
def setmask(command, data, cdata):
"""
Sets the mask on a dset and dumps a file containing the mask which can be applied
to other dsets using 'appmask'. This is an interactive routine which will request
input from the user and is better not used in batch processing. Repeated calls of
this routine can be used to build complex masks. The masks are always applied in
the original order so that you can mask then partially unmask for example. Note that
whatever slot you choose to define the mask will always end up masked; if you don't
want this you may want to make a copy.
Interactive usage:
setmask slot mfile append [device reset x1 x2 y1 y2] mask type
Arguments:
slot -- an example slot to plot.
mfile -- mask file
append -- append to an old mask file if possible
device -- plot device, e.g. '/xs'
reset -- rest plot limits or not
x1 -- left X plot limit
x2 -- right X plot limit
y1 -- bottom Y plot limit
y2 -- top Y plot limit
mask -- mask 'M', or unmask 'U' or quit 'Q'.
type -- type of mask: 'X' masks using ranges in X
Mask types:
X -- mask a range in X
Y -- mask a range in Y
I -- mask a range of pixel indices
P -- mask in 'phase', i.e. a range that repeats periodically.
"""
import trm.dnl.mask as mask
# generate arguments
inpt = inp.Input(DINT_ENV, DINT_DEF, inp.clist(command))
# register parameters
inpt.register('slot', inp.Input.LOCAL, inp.Input.PROMPT)
inpt.register('mfile', inp.Input.GLOBAL, inp.Input.PROMPT)
inpt.register('append', inp.Input.LOCAL, inp.Input.PROMPT)
inpt.register('device', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('reset', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('x1', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('x2', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('y1', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('y2', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('mask', inp.Input.LOCAL, inp.Input.PROMPT)
inpt.register('type', inp.Input.LOCAL, inp.Input.PROMPT)
# get inputs
slots = inpt.get_value('slot', 'slot to plot for mask definition', '1')
slist = interp_slots(slots, True, data, nfind=1)
dset = data[slist[0]]
device = inpt.get_value('device', 'plot device', '/xs')
# mask file
mfile = inpt.get_value('mfile', 'mask file to save results to', subs.Fname('mask','.msk', subs.Fname.NEW))
append = inpt.get_value('append', 'add to an old mask file if possible', True)
if append and mfile.exists():
mptr = open(mfile,'rb')
gmask = pickle.load(mptr)
gmask.app_mask(dset)
mptr.close()
else:
gmask = mask.Gmask()
# other parameters
reset = inpt.get_value('reset', 'reset plot limits automatically?', True)
# compute default limits
(x1,x2,y1,y2) = dset.plimits()
if (x2 - x1) < (x1+x2)/2./100.:
xoff = x1
x1 = 0.
x2 -= xoff
else:
xoff = 0.
yoff = 0.
if reset:
inpt.set_default('x1', x1)
inpt.set_default('x2', x2)
inpt.set_default('y1', y1)
inpt.set_default('y2', y2)
x1 = inpt.get_value('x1', 'left-hand limit of plot', x1)
x2 = inpt.get_value('x2', 'right-hand limit of plot', x2)
y1 = inpt.get_value('y1', 'bottom limit of plot', y1)
y2 = inpt.get_value('y2', 'top limit of plot', y2)
m_or_u = inpt.get_value('mask', 'M(ask), U(nmask) or Q(uit)?', 'm', lvals=['m', 'M', 'u', 'U', 'q', 'Q'])
if m_or_u.upper() == 'M':
mtext = 'mask'
else:
mtext = 'unmask'
mask_type = inpt.get_value('type', 'X, Y, P(hase), I(ndex) or Q(uit)?', 'x',
lvals=['x', 'X', 'y', 'Y', 'p', 'P', 'i', 'I', 'q', 'Q'])
# initialise plot
try:
pg.pgopen(device)
pg.pgsch(1.5)
pg.pgscf(2)
pg.pgslw(2)
pg.pgsci(4)
pg.pgenv(x1,x2,y1,y2,0,0)
(xlabel,ylabel) = dset.plabel(xoff,yoff)
pg.pgsci(2)
pg.pglab(xlabel, ylabel, dset.title)
# plot the dset
dset.plot(xoff,yoff)
x = (x1+x2)/2.
y = (y1+y2)/2.
# now define masks
ch = 'X'
while ch.upper() != 'Q':
# go through mask options
if mask_type.upper() == 'X':
print('Set cursor at the one end of the X range, Q to quit')
(xm1,y,ch) = pg.pgband(7,0,x,y)
if ch.upper() != 'Q':
print('Set cursor at the other end of ' +
'the X range, Q to quit')
xm2,y,ch = pg.pgband(7,0,xm1,y)
if ch.upper() != 'Q':
if xm1 > xm2: xm1,xm2 = xm2,xm1
umask = mask.Xmask(xoff+xm1, xoff+xm2, m_or_u.upper() == 'M')
elif mask_type.upper() == 'I':
print('Place cursor near a point and click to ' +
mtext + ' it, Q to quit')
x,y,ch = pg.pgband(7,0,x,y)
if ch.upper() != 'Q':
xmm1,xmm2,ymm1,ymm2 = pg.pgqvp(2)
xscale = (xmm2-xmm1)/(x2-x1)
yscale = (ymm2-ymm1)/(y2-y1)
# only consider good data of opposite 'polarity' to the
# change we are making.
ok = (dset.good == True) & \
(dset.mask == (m_or_u.upper() == 'M'))
if len(dset.x.dat[ok == True]):
# compute physical squared distance of cursor from
# points
sqdist = npy.power(
xscale*(dset.x.dat[ok]-(xoff+x)),2) + \
npy.power(yscale*(dset.y.dat[ok]-(yoff+y)),2)
# select the index giving the minimum distance
indices = npy.arange(len(dset))[ok]
index = indices[sqdist.min() == sqdist][0]
umask = mask.Imask(index, m_or_u.upper() == 'M')
else:
print('There seem to be no data to ' + mtext +
'; data already ' + mtext + 'ed are ignored.')
umask = None
if ch.upper() != 'Q' and umask is not None:
gmask.append(umask)
umask.app_mask(dset)
print('overplotting data')
# over-plot the dset
dset.plot(xoff,yoff)
pg.pgclos()
except pg.ioerror, err:
raise DintError(str(err))
def plot(command, data, group, cdata):
"""
Plots dsets from a dictionary called data.
Interactive usage:
plot slots [device x1 x2 y1 y2 xoff ysep=0 pmask]
Arguments:
slots -- range of slots as in '1-10', or just a single slot '9' to plot, or a group
name such as 'ippeg'.
device -- plot device (e.g. '/xs', '3/xs', 'hardcopy.ps/cps')
x1 -- left-hand plot limit
x2 -- right-hand plot limit. Set = x1 for automatic determination
y1 -- lower plot limit
y2 -- upper plot limit. Set = y1 for automatic determination
xoff -- offset to start X axis from, 0 for automatic determination.
ysep -- separation in y
pmask -- whether to plot masked data
"""
# generate arguments
inpt = inp.Input(DINT_ENV, DINT_DEF, inp.clist(command))
# register parameters
inpt.register('slots', inp.Input.LOCAL, inp.Input.PROMPT)
inpt.register('device', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('x1', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('x2', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('y1', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('y2', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('xoff', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('ysep', inp.Input.LOCAL, inp.Input.HIDE)
inpt.register('pmask', inp.Input.LOCAL, inp.Input.HIDE)
# get inputs
slots = inpt.get_value('slots', 'slots to plot', '1')
slist = interp_slots(slots, True, data, group)
device = inpt.get_value('device', 'plot device', '/xs')
x1 = inpt.get_value('x1', 'left-hand plot limit', 0.0)
x2 = inpt.get_value('x2', 'right-hand plot limit', 0.0)
y1 = inpt.get_value('y1', 'lower plot limit', 0.0)
y2 = inpt.get_value('y2', 'upper plot limit', 0.0)
xoff = inpt.get_value('xoff', 'X offset', 0.0)
inpt.set_default('ysep', 0.0)
ysep = inpt.get_value('ysep', 'vertical separation between successive dsets', 0.0)
pmask = inpt.get_value('pmask', 'do you want to plot the masked data too?', True)
# Determine limits automatically if required
if xoff !=0. or x1 == x2 or y1 == y2:
xa1 = None
xa2 = None
ya1 = None
ya2 = None
yadd = 0.
for i in slist:
(xi1,xi2,yi1,yi2) = data[i].plimits()
if xa1 is None:
xa1 = xi1
else:
xa1 = min(xa1, xi1)
if xa2 is None:
xa2 = xi2
else:
xa2 = max(xa2, xi2)
if ya1 is None and yi1 is not None:
ya1 = yi1 + yadd
elif yi1 is not None:
ya1 = min(ya1, yi1 + yadd)
if ya2 is None and yi2 is not None:
ya2 = yi2 + yadd
elif yi2 is not None:
ya2 = max(ya2, yi2 + yadd)
yadd += ysep
if xa1 is None or xa2 is None or ya1 is None or ya2 is None:
raise DintError('plot: no automatic limits could be evaluated; possibly no good data to plot?')
if xoff == 0.0 and (xa2 - xa1) < (xa1+xa2)/2./100.:
xoff = xa1
xa1 -= xoff
xa2 -= xoff
if x1 == x2:
x1 = xa1
x2 = xa2
if y1 == y2:
y1 = ya1
y2 = ya2
try:
pg.pgopen(device)
pg.pgsci(4)
pg.pgenv(x1, x2, y1, y2, 0, 0)
pg.pgsci(2)
first = data[slist[0]]
xlabel = first.x.label if xoff == 0 else first.x.label + '-' + str(xoff)
xlabel += ' (' + first.x.units + ')'
ylabel = first.y.label + ' (' + first.y.units + ')'
pg.pglab(xlabel, ylabel, first.title)
yadd = 0.
for slot in slist:
data[slot].plot(xoff,yoff=-yadd,masked=pmask)
if not cdata.mute:
print('Plotted slot ' + str(slot))
yadd += ysep
pg.pgclos()
except pg.ioerror, err:
raise DintError(str(err))
def main(options):
global keepPlotting
keepPlotting = True
debug = options.debug
inputMS = options.inms
if inputMS == "":
print "Error: You must specify a MS name."
print ' Use "uvplot.py -h" to get help.'
return
if inputMS.endswith("/"):
inputMS = inputMS[:-1]
inputMSbasename = inputMS.split("/")[-1]
if inputMSbasename == "":
# The user has not specified the full path of the MS
inputMSbasename = inputMS
device = options.device
if device == "?":
ppgplot.pgldev()
return
xaxis = options.xaxis
yaxis = options.yaxis
column = options.column
nx, ny = options.nxy.split(",")
axlimits = options.axlimits.split(",")
if len(axlimits) == 4:
xmin, xmax, ymin, ymax = axlimits
else:
print "Error: You must specify four axis limits"
return
showFlags = options.flag
flagCol = options.colflag
showAutocorr = options.autocorr
showStats = options.statistics
timeslots = options.timeslots.split(",")
if len(timeslots) != 2:
print "Error: Timeslots format is start,end"
return
for i in range(len(timeslots)):
timeslots[i] = int(timeslots[i])
antToPlotSpl = options.antennas.split(",")
antToPlot = []
for i in range(len(antToPlotSpl)):
tmpspl = antToPlotSpl[i].split("..")
if len(tmpspl) == 1:
antToPlot.append(int(antToPlotSpl[i]))
elif len(tmpspl) == 2:
for j in range(int(tmpspl[0]), int(tmpspl[1]) + 1):
antToPlot.append(j)
else:
print "Error: Could not understand antenna list."
return
polarizations = options.polar.split(",")
for i in range(len(polarizations)):
polarizations[i] = int(polarizations[i])
convertStokes = options.stokes
operation = options.operation
if operation != "":
operation = int(operation)
if convertStokes:
print "Error: Stokes conversion is not compatible with special operations"
return
channels = options.channels.split(",")
if len(channels) != 2:
print "Error: Channels format is start,end"
return
for i in range(len(channels)):
channels[i] = int(channels[i])
if channels[1] == -1:
channels[1] = None # last element even if there is only one
else:
channels[1] += 1
queryMode = options.query
doUnwrap = options.wrap
if not queryMode:
# open the graphics device, use the right number of panels
ppgplot.pgbeg(device, int(nx), int(ny))
# set the font size
ppgplot.pgsch(1.5)
ppgplot.pgvstd()
# open the main table and print some info about the MS
t = pt.table(inputMS, readonly=True, ack=False)
firstTime = t.getcell("TIME", 0)
lastTime = t.getcell("TIME", t.nrows() - 1)
intTime = t.getcell("INTERVAL", 0)
print "Integration time:\t%f sec" % (intTime)
nTimeslots = (lastTime - firstTime) / intTime
if timeslots[1] == -1:
timeslots[1] = nTimeslots
else:
timeslots[1] += 1
print "Number of timeslots:\t%d" % (nTimeslots)
# open the antenna and spectral window subtables
tant = pt.table(t.getkeyword("ANTENNA"), readonly=True, ack=False)
tsp = pt.table(t.getkeyword("SPECTRAL_WINDOW"), readonly=True, ack=False)
numChannels = len(tsp.getcell("CHAN_FREQ", 0))
print "Number of channels:\t%d" % (numChannels)
print "Reference frequency:\t%5.2f MHz" % (tsp.getcell("REF_FREQUENCY", 0) / 1.0e6)
# Station names
antList = tant.getcol("NAME")
if len(antToPlot) == 1 and antToPlot[0] == -1:
antToPlot = range(len(antList))
print "Station list (only starred stations will be plotted):"
for i in range(len(antList)):
star = " "
if i in antToPlot:
star = "*"
print "%s %2d\t%s" % (star, i, antList[i])
# Bail if we're in query mode
if queryMode:
return
# select by time from the beginning, and only use specified antennas
tsel = t.query(
"TIME >= %f AND TIME <= %f AND ANTENNA1 IN %s AND ANTENNA2 IN %s"
% (firstTime + timeslots[0] * intTime, firstTime + timeslots[1] * intTime, str(antToPlot), str(antToPlot))
)
# values to use for each polarization
plotColors = [1, 2, 3, 4]
labXPositions = [0.35, 0.45, 0.55, 0.65]
labYPositions = [1.0, 1.0, 1.0, 1.0]
if convertStokes:
polLabels = ["I", "Q", "U", "V"]
else:
polLabels = ["XX", "XY", "YX", "YY"]
# define nicely written axis labels
axisLabels = {
"time": "Time",
"chan": "Channel",
"freq": "Frequency [MHz]",
"amp": "Visibility amplitude",
"real": "Real part of visibility",
"imag": "Imaginary part of visibility",
"phase": "Visibility phase [radians]",
}
# Now we loop through the baselines
ppgplot.pgpage()
for tpart in tsel.iter(["ANTENNA1", "ANTENNA2"]):
if not keepPlotting:
return
ant1 = tpart.getcell("ANTENNA1", 0)
ant2 = tpart.getcell("ANTENNA2", 0)
if ant1 not in antToPlot or ant2 not in antToPlot:
continue
if ant1 == ant2:
if not showAutocorr:
continue
# Get the values to plot, strategy depends on axis type
if xaxis == "time":
xaxisvals = getXAxisVals(tpart, xaxis, channels)
yaxisvals = getYAxisVals(
tpart, yaxis, column, operation, showFlags, flagCol, channels, doUnwrap, convertStokes
)
else:
xaxisvals = getXAxisVals(tsp, xaxis, channels)
yaxisvals = getYAxisVals(
tpart, yaxis, column, operation, showFlags, flagCol, channels, doUnwrap, convertStokes, xaxistype=1
)
if xaxisvals == None: # This baseline must be empty, go to next one
print "No good data on baseline %s - %s" % (antList[ant1], antList[ant2])
continue
if debug:
print xaxisvals.shape
print yaxisvals.shape
for r in range(len(xaxisvals)):
print "%s" % yaxisvals[r]
if len(xaxisvals) != len(yaxisvals): # something is wrong
print "Error: X and Y axis types incompatible"
return
# Plot the data, each polarization in a different color
ppgplot.pgsci(1)
if xmin == "":
minx = xaxisvals.min()
else:
minx = float(xmin)
if xmax == "":
maxx = xaxisvals.max()
else:
maxx = float(xmax)
if ymin == "":
miny = yaxisvals.min()
if numpy.ma.getmaskarray(yaxisvals.min()):
print "All data flagged on baseline %s - %s" % (antList[ant1], antList[ant2])
continue
else:
miny = float(ymin)
if ymax == "":
maxy = yaxisvals.max()
else:
maxy = float(ymax)
if minx == maxx:
minx -= 1.0
maxx += 1.0
else:
diffx = maxx - minx
minx -= 0.02 * diffx
maxx += 0.02 * diffx
if miny == maxy:
miny -= 1.0
maxy += 1.0
else:
diffy = maxy - miny
miny -= 0.02 * diffy
maxy += 0.02 * diffy
# ppgplot.pgpage()
ppgplot.pgswin(minx, maxx, miny, maxy)
if xaxis == "time":
ppgplot.pgtbox("ZHOBCNST", 0.0, 0, "BCNST", 0.0, 0)
else:
ppgplot.pgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0)
# ppgplot.pglab(axisLabels[xaxis], axisLabels[yaxis], '%s - %s'%(antList[ant1],antList[ant2]))
# ppgplot.pgmtxt('T', 3.0, 0.5, 0.5, inputMSbasename)
ppgplot.pglab(
axisLabels[xaxis],
axisLabels[yaxis],
inputMSbasename + "(" + getDataDescription(column) + "): %s - %s" % (antList[ant1], antList[ant2]),
)
if operation != 0:
# some operations is defined
if operation == 1:
label = "XX-YY"
elif operation == 2:
label = "XY.YX*"
else:
print "Special operation not defined"
return
ppgplot.pgsci(plotColors[0])
tmpvals = yaxisvals
print "Baseline", antList[ant1], "-", antList[ant2], ": Plotting", len(
tmpvals[~tmpvals.mask]
), "points of " + label
ppgplot.pgpt(xaxisvals[~tmpvals.mask], tmpvals[~tmpvals.mask], 1)
addInfo(showStats, tmpvals[~tmpvals.mask], label, labXPositions[1], labYPositions[1])
else:
for j in polarizations:
ppgplot.pgsci(plotColors[j])
tmpvals = yaxisvals[:, j]
if j == polarizations[0]:
print "Baseline", antList[ant1], "-", antList[ant2], ": Plotting", len(
tmpvals[~tmpvals.mask]
), "points per polarization"
ppgplot.pgpt(xaxisvals[~tmpvals.mask], tmpvals[~tmpvals.mask], 1)
addInfo(showStats, tmpvals[~tmpvals.mask], polLabels[j], labXPositions[j], labYPositions[j])
ppgplot.pgpage()
# Close the PGPLOT device
ppgplot.pgclos()
def joy_division_plot(pulses, timeseries, downfactor=1, hgt_mult=1):
"""Plot each pulse profile on the same plot separated
slightly on the vertical axis.
'timeseries' is the Datfile object dissected.
Downsample profiles by factor 'downfactor' before plotting.
hgt_mult is a factor to stretch the height of the paper.
"""
first = True
ppgplot.pgbeg("%s.joydiv.ps/CPS" % \
os.path.split(timeseries.basefn)[1], 1, 1)
ppgplot.pgpap(10.25, hgt_mult*8.5/11.0) # Letter landscape
# ppgplot.pgpap(7.5, 11.7/8.3) # A4 portrait, doesn't print properly
ppgplot.pgiden()
ppgplot.pgsci(1)
# Set up main plot
ppgplot.pgsvp(0.1, 0.9, 0.1, 0.8)
ppgplot.pglab("Profile bin", "Single pulse profiles", "")
to_plot = []
xmin = 0
xmax = None
ymin = None
ymax = None
for pulse in pulses:
vertical_offset = (pulse.number-1)*JOYDIV_SEP
copy_of_pulse = pulse.make_copy()
if downfactor > 1:
# Interpolate before downsampling
interp = ((copy_of_pulse.N/downfactor)+1)*downfactor
copy_of_pulse.interpolate(interp)
copy_of_pulse.downsample(downfactor)
# copy_of_pulse.scale()
if first:
summed_prof = copy_of_pulse.profile.copy()
first = False
else:
summed_prof += copy_of_pulse.profile
prof = copy_of_pulse.profile + vertical_offset
min = prof.min()
if ymin is None or min < ymin:
ymin = min
max = prof.max()
if ymax is None or max > ymax:
ymax = max
max = prof.size-1
if xmax is None or max > xmax:
xmax = max
to_plot.append(prof)
yspace = 0.1*ymax
ppgplot.pgswin(0, xmax, ymin-yspace, ymax+yspace)
for prof in to_plot:
ppgplot.pgline(np.arange(0,prof.size), prof)
ppgplot.pgbox("BNTS", 0, 0, "BC", 0, 0)
# Set up summed profile plot
ppgplot.pgsvp(0.1, 0.9, 0.8, 0.9)
ppgplot.pglab("", "Summed profile", "Pulses from %s" % timeseries.datfn)
summed_prof = summed_prof - summed_prof.mean()
ppgplot.pgswin(0, xmax, summed_prof.min(), summed_prof.max())
ppgplot.pgline(np.arange(0, summed_prof.size), summed_prof)
ppgplot.pgbox("C", 0, 0, "BC", 0, 0)
ppgplot.pgclos()
def main(options):
debug = options.debug
MSlist = []
device = options.device
if device == '?':
ppgplot.pgldev()
return
for inmspart in options.inms.split(','):
for msname in glob.iglob(inmspart):
MSlist.append(msname)
if len(MSlist) == 0:
print('Error: You must specify at least one MS name.')
print(' Use "uvplot.py -h" to get help.')
return
if len(MSlist) > 1:
print('WARNING: Antenna selection (other than all) may not work well')
print(' when plotting more than one MS. Carefully inspect the')
print(' listings of antenna numbers/names!')
if options.title == '':
plottitle = options.inms
else:
plottitle = options.title
axlimits = options.axlimits.split(',')
if len(axlimits) == 4:
xmin, xmax, ymin, ymax = axlimits
else:
print('Error: You must specify four axis limits')
return
timeslots = options.timeslots.split(',')
if len(timeslots) != 3:
print('Error: Timeslots format is start,skip,end')
return
for i in range(len(timeslots)):
timeslots[i] = int(timeslots[i])
if timeslots[i] < 0:
print('Error: timeslots values must not be negative')
return
doPlotColors = options.colors
antToPlotSpl = options.antennas.split(',')
antToPlot = []
for i in range(len(antToPlotSpl)):
tmpspl = antToPlotSpl[i].split('..')
if len(tmpspl) == 1:
antToPlot.append(int(antToPlotSpl[i]))
elif len(tmpspl) == 2:
for j in range(int(tmpspl[0]), int(tmpspl[1]) + 1):
antToPlot.append(j)
else:
print('Error: Could not understand antenna list.')
return
queryMode = options.query
plotLambda = options.kilolambda
badval = 0.0
xaxisvals0 = numpy.array([])
yaxisvals0 = numpy.array([])
xaxisvals1 = numpy.array([])
yaxisvals1 = numpy.array([])
xaxisvals2 = numpy.array([])
yaxisvals2 = numpy.array([])
xaxisvals3 = numpy.array([])
yaxisvals3 = numpy.array([])
xaxisvals4 = numpy.array([])
yaxisvals4 = numpy.array([])
xaxisvals5 = numpy.array([])
yaxisvals5 = numpy.array([])
savex0 = numpy.array([])
savey0 = numpy.array([])
savex1 = numpy.array([])
savey1 = numpy.array([])
savex2 = numpy.array([])
savey2 = numpy.array([])
savex3 = numpy.array([])
savey3 = numpy.array([])
savex4 = numpy.array([])
savey4 = numpy.array([])
savex5 = numpy.array([])
savey5 = numpy.array([])
numPlotted = 0
ptcolor = 0
for inputMS in MSlist:
# open the main table and print some info about the MS
print('Getting info for', inputMS)
t = pt.table(inputMS, readonly=True, ack=False)
tfreq = pt.table(t.getkeyword('SPECTRAL_WINDOW'),
readonly=True,
ack=False)
ref_freq = tfreq.getcol('REF_FREQUENCY', nrow=1)[0]
ch_freq = tfreq.getcol('CHAN_FREQ', nrow=1)[0]
print('Reference frequency:\t%f MHz' % (ref_freq / 1.e6))
if options.wideband:
ref_wavelength = 2.99792458e8 / ch_freq
else:
ref_wavelength = [2.99792458e8 / ref_freq]
print('Reference wavelength:\t%f m' % (ref_wavelength[0]))
if options.sameuv and numPlotted > 0:
print('Assuming same uvw as first MS!')
if plotLambda:
for w in ref_wavelength:
xaxisvals0 = numpy.append(
xaxisvals0, [savex0 / w / 1000., -savex0 / w / 1000.])
yaxisvals0 = numpy.append(
yaxisvals0, [savey0 / w / 1000., -savey0 / w / 1000.])
xaxisvals1 = numpy.append(
xaxisvals1, [savex1 / w / 1000., -savex1 / w / 1000.])
yaxisvals1 = numpy.append(
yaxisvals1, [savey1 / w / 1000., -savey1 / w / 1000.])
xaxisvals2 = numpy.append(
xaxisvals2, [savex2 / w / 1000., -savex2 / w / 1000.])
yaxisvals2 = numpy.append(
yaxisvals2, [savey2 / w / 1000., -savey2 / w / 1000.])
xaxisvals3 = numpy.append(
xaxisvals3, [savex3 / w / 1000., -savex3 / w / 1000.])
yaxisvals3 = numpy.append(
yaxisvals3, [savey3 / w / 1000., -savey3 / w / 1000.])
xaxisvals4 = numpy.append(
xaxisvals4, [savex4 / w / 1000., -savex4 / w / 1000.])
yaxisvals4 = numpy.append(
yaxisvals4, [savey4 / w / 1000., -savey4 / w / 1000.])
xaxisvals5 = numpy.append(
xaxisvals5, [savex5 / w / 1000., -savex5 / w / 1000.])
yaxisvals5 = numpy.append(
yaxisvals5, [savey5 / w / 1000., -savey5 / w / 1000.])
else:
print(
'Plotting more than one MS with same uv, all in meters... do you want -k?'
)
xaxisvals0 = numpy.append(xaxisvals0, [savex0, -savex0])
yaxisvals0 = numpy.append(yaxisvals0, [savey0, -savey0])
xaxisvals1 = numpy.append(xaxisvals1, [savex1, -savex1])
yaxisvals1 = numpy.append(yaxisvals1, [savey1, -savey1])
xaxisvals2 = numpy.append(xaxisvals2, [savex2, -savex2])
yaxisvals2 = numpy.append(yaxisvals2, [savey2, -savey2])
xaxisvals3 = numpy.append(xaxisvals3, [savex3, -savex3])
yaxisvals3 = numpy.append(yaxisvals3, [savey3, -savey3])
xaxisvals4 = numpy.append(xaxisvals4, [savex4, -savex4])
yaxisvals4 = numpy.append(yaxisvals4, [savey4, -savey4])
xaxisvals5 = numpy.append(xaxisvals5, [savex5, -savex5])
yaxisvals5 = numpy.append(yaxisvals5, [savey5, -savey5])
continue
firstTime = t.getcell("TIME", 0)
lastTime = t.getcell("TIME", t.nrows() - 1)
intTime = t.getcell("INTERVAL", 0)
print('Integration time:\t%f sec' % (intTime))
nTimeslots = (lastTime - firstTime) / intTime
print('Number of timeslots:\t%d' % (nTimeslots))
if timeslots[1] == 0:
if nTimeslots >= 100:
timeskip = int(nTimeslots / 100)
else:
timeskip = 1
else:
timeskip = int(timeslots[1])
print('For each baseline, plotting one point every %d samples' %
(timeskip))
if timeslots[2] == 0:
timeslots[2] = nTimeslots
# open the antenna subtable
tant = pt.table(t.getkeyword('ANTENNA'), readonly=True, ack=False)
# Station names
antList = tant.getcol('NAME')
if len(antToPlot) == 1 and antToPlot[0] == -1:
antToPlot = list(range(len(antList)))
print('Station list (only starred stations will be plotted):')
for i in range(len(antList)):
star = ' '
if i in antToPlot: star = '*'
print('%s %2d\t%s' % (star, i, antList[i]))
# Bail if we're in query mode
if queryMode:
return
# select by time from the beginning, and only use specified antennas
tsel = t.query(
'TIME >= %f AND TIME <= %f AND ANTENNA1 IN %s AND ANTENNA2 IN %s' %
(firstTime + timeslots[0] * intTime, firstTime +
timeslots[2] * intTime, str(antToPlot), str(antToPlot)),
columns='ANTENNA1,ANTENNA2,UVW')
# Now we loop through the baselines
i = 0
nb = (len(antToPlot) * (len(antToPlot) - 1)) / 2
sys.stdout.write('Reading uvw for %d baselines: %04d/%04d' %
(nb, i, nb))
sys.stdout.flush()
for tpart in tsel.iter(["ANTENNA1", "ANTENNA2"]):
ant1 = tpart.getcell("ANTENNA1", 0)
ant2 = tpart.getcell("ANTENNA2", 0)
if ant1 not in antToPlot or ant2 not in antToPlot: continue
if ant1 == ant2: continue
i += 1
sys.stdout.write('\b\b\b\b\b\b\b\b\b%04d/%04d' % (i, nb))
sys.stdout.flush()
if doPlotColors:
stNameStr = antList[ant1][0] + antList[ant2][0]
if stNameStr == 'CC': ptcolor = 0
elif stNameStr == 'RR': ptcolor = 1
elif 'C' in stNameStr and 'R' in stNameStr: ptcolor = 2
elif 'C' in stNameStr: ptcolor = 3
elif 'R' in stNameStr: ptcolor = 4
else: ptcolor = 5
# Get the values to plot
uvw = tpart.getcol('UVW', rowincr=timeskip)
if numPlotted == 0:
savex0 = numpy.append(savex0, [uvw[:, 0], -uvw[:, 0]])
savey0 = numpy.append(savey0, [uvw[:, 1], -uvw[:, 1]])
savex1 = numpy.append(savex1, [uvw[:, 0], -uvw[:, 0]])
savey1 = numpy.append(savey1, [uvw[:, 1], -uvw[:, 1]])
savex2 = numpy.append(savex2, [uvw[:, 0], -uvw[:, 0]])
savey2 = numpy.append(savey2, [uvw[:, 1], -uvw[:, 1]])
savex3 = numpy.append(savex3, [uvw[:, 0], -uvw[:, 0]])
savey3 = numpy.append(savey3, [uvw[:, 1], -uvw[:, 1]])
savex4 = numpy.append(savex4, [uvw[:, 0], -uvw[:, 0]])
savey4 = numpy.append(savey4, [uvw[:, 1], -uvw[:, 1]])
savex5 = numpy.append(savex5, [uvw[:, 0], -uvw[:, 0]])
savey5 = numpy.append(savey5, [uvw[:, 1], -uvw[:, 1]])
if plotLambda:
for w in ref_wavelength:
if ptcolor == 0:
xaxisvals0 = numpy.append(
xaxisvals0,
[uvw[:, 0] / w / 1000., -uvw[:, 0] / w / 1000.])
yaxisvals0 = numpy.append(
yaxisvals0,
[uvw[:, 1] / w / 1000., -uvw[:, 1] / w / 1000.])
elif ptcolor == 1:
xaxisvals1 = numpy.append(
xaxisvals1,
[uvw[:, 0] / w / 1000., -uvw[:, 0] / w / 1000.])
yaxisvals1 = numpy.append(
yaxisvals1,
[uvw[:, 1] / w / 1000., -uvw[:, 1] / w / 1000.])
elif ptcolor == 2:
xaxisvals2 = numpy.append(
xaxisvals2,
[uvw[:, 0] / w / 1000., -uvw[:, 0] / w / 1000.])
yaxisvals2 = numpy.append(
yaxisvals2,
[uvw[:, 1] / w / 1000., -uvw[:, 1] / w / 1000.])
elif ptcolor == 3:
xaxisvals3 = numpy.append(
xaxisvals3,
[uvw[:, 0] / w / 1000., -uvw[:, 0] / w / 1000.])
yaxisvals3 = numpy.append(
yaxisvals3,
[uvw[:, 1] / w / 1000., -uvw[:, 1] / w / 1000.])
elif ptcolor == 4:
xaxisvals4 = numpy.append(
xaxisvals4,
[uvw[:, 0] / w / 1000., -uvw[:, 0] / w / 1000.])
yaxisvals4 = numpy.append(
yaxisvals4,
[uvw[:, 1] / w / 1000., -uvw[:, 1] / w / 1000.])
elif ptcolor == 5:
xaxisvals5 = numpy.append(
xaxisvals5,
[uvw[:, 0] / w / 1000., -uvw[:, 0] / w / 1000.])
yaxisvals5 = numpy.append(
yaxisvals5,
[uvw[:, 1] / w / 1000., -uvw[:, 1] / w / 1000.])
else:
if ptcolor == 0:
xaxisvals0 = numpy.append(xaxisvals0,
[uvw[:, 0], -uvw[:, 0]])
yaxisvals0 = numpy.append(yaxisvals0,
[uvw[:, 1], -uvw[:, 1]])
elif ptcolor == 1:
xaxisvals1 = numpy.append(xaxisvals1,
[uvw[:, 0], -uvw[:, 0]])
yaxisvals1 = numpy.append(yaxisvals1,
[uvw[:, 1], -uvw[:, 1]])
elif ptcolor == 2:
xaxisvals2 = numpy.append(xaxisvals2,
[uvw[:, 0], -uvw[:, 0]])
yaxisvals2 = numpy.append(yaxisvals2,
[uvw[:, 1], -uvw[:, 1]])
elif ptcolor == 3:
xaxisvals3 = numpy.append(xaxisvals3,
[uvw[:, 0], -uvw[:, 0]])
yaxisvals3 = numpy.append(yaxisvals3,
[uvw[:, 1], -uvw[:, 1]])
elif ptcolor == 4:
xaxisvals4 = numpy.append(xaxisvals4,
[uvw[:, 0], -uvw[:, 0]])
yaxisvals4 = numpy.append(yaxisvals4,
[uvw[:, 1], -uvw[:, 1]])
elif ptcolor == 5:
xaxisvals5 = numpy.append(xaxisvals5,
[uvw[:, 0], -uvw[:, 0]])
yaxisvals5 = numpy.append(yaxisvals5,
[uvw[:, 1], -uvw[:, 1]])
#if debug:
# print uvw.shape
# print xaxisvals.shape
# print yaxisvals.shape
#else:
# sys.stdout.write('.')
# sys.stdout.flush()
sys.stdout.write(' Done!\n')
numPlotted += 1
print('Plotting uv points ...')
# open the graphics device, using only one panel
ppgplot.pgbeg(device, 1, 1)
# set the font size
ppgplot.pgsch(1)
ppgplot.pgvstd()
xaxisvals = numpy.append(
xaxisvals0,
numpy.append(
xaxisvals1,
numpy.append(
xaxisvals2,
numpy.append(xaxisvals3, numpy.append(xaxisvals4,
xaxisvals5)))))
yaxisvals = numpy.append(
yaxisvals0,
numpy.append(
yaxisvals1,
numpy.append(
yaxisvals2,
numpy.append(yaxisvals3, numpy.append(yaxisvals4,
yaxisvals5)))))
tmpvals0 = numpy.sqrt(xaxisvals0**2 + yaxisvals0**2)
tmpvals1 = numpy.sqrt(xaxisvals1**2 + yaxisvals1**2)
tmpvals2 = numpy.sqrt(xaxisvals2**2 + yaxisvals2**2)
tmpvals3 = numpy.sqrt(xaxisvals3**2 + yaxisvals3**2)
tmpvals4 = numpy.sqrt(xaxisvals4**2 + yaxisvals4**2)
tmpvals5 = numpy.sqrt(xaxisvals5**2 + yaxisvals5**2)
# Plot the data
if debug:
print(xaxisvals0[tmpvals0 != badval])
print(yaxisvals0[tmpvals0 != badval])
ppgplot.pgsci(1)
uvmax = max(xaxisvals.max(), yaxisvals.max())
uvmin = min(xaxisvals.min(), yaxisvals.min())
uvuplim = 0.02 * (uvmax - uvmin) + uvmax
uvlolim = uvmin - 0.02 * (uvmax - uvmin)
if xmin == '':
minx = uvlolim
else:
minx = float(xmin)
if xmax == '':
maxx = uvuplim
else:
maxx = float(xmax)
if ymin == '':
miny = uvlolim
else:
miny = float(ymin)
if ymax == '':
maxy = uvuplim
else:
maxy = float(ymax)
if minx == maxx:
minx = -1.0
maxx = 1.0
if miny == maxy:
miny = -1.0
maxy = 1.0
ppgplot.pgpage()
ppgplot.pgswin(minx, maxx, miny, maxy)
ppgplot.pgbox('BCNST', 0.0, 0, 'BCNST', 0.0, 0)
if plotLambda:
ppgplot.pglab('u [k\gl]', 'v [k\gl]', '%s' % (plottitle))
else:
ppgplot.pglab('u [m]', 'v [m]', '%s' % (plottitle))
ppgplot.pgpt(xaxisvals0[tmpvals0 != badval],
yaxisvals0[tmpvals0 != badval], 1)
#if doPlotColors: ppgplot.pgmtxt('T', 1, 0.35, 0.5, 'C-C')
ppgplot.pgsci(2)
ppgplot.pgpt(xaxisvals1[tmpvals1 != badval],
yaxisvals1[tmpvals1 != badval], 1)
#if doPlotColors: ppgplot.pgmtxt('T', 1, 0.50, 0.5, 'R-R')
ppgplot.pgsci(4)
ppgplot.pgpt(xaxisvals2[tmpvals2 != badval],
yaxisvals2[tmpvals2 != badval], 1)
#if doPlotColors: ppgplot.pgmtxt('T', 1, 0.65, 0.5, 'C-R')
ppgplot.pgsci(3)
ppgplot.pgpt(xaxisvals3[tmpvals3 != badval],
yaxisvals3[tmpvals3 != badval], 1)
#if doPlotColors: ppgplot.pgmtxt('T', 1, 0.55, 0.5, 'C-I')
ppgplot.pgsci(5)
ppgplot.pgpt(xaxisvals4[tmpvals4 != badval],
yaxisvals4[tmpvals4 != badval], 1)
#if doPlotColors: ppgplot.pgmtxt('T', 1, 0.65, 0.5, 'R-I')
ppgplot.pgsci(6)
ppgplot.pgpt(xaxisvals5[tmpvals5 != badval],
yaxisvals5[tmpvals5 != badval], 1)
#if doPlotColors: ppgplot.pgmtxt('T', 1, 0.75, 0.5, 'I-I')
# Close the PGPLOT device
ppgplot.pgclos()
def plot(self, vlo=2., vhi=98., nc=-1, method='p', mpl=False, cmap=CMDEF, \
close=True, x1=None, x2=None, y1=None, y2=None, sepmin=1.):
"""
Plots an MCCD using pgplot or matplotlib if preferred.
:Parameters:
vlo : float
number specifying the lowest level to plot (default as a percentile)
vhi : float
number specifying the lowest level to plot (default as a percentile)
nc : int
CCD number (starting from 0, -1 for all)
method : string
how vlo and vhi are to be interpreted. 'p' = percentile, 'a' = automatic (min to max,
vlo and vhi are irrelevant), 'd' = direct, i.e. just take the values given.
mpl : bool
True to prefer matplotlib over pgplot (which may not even be an option)
cmap : matplotlib.cm.binary
colour map if using matplotlib
close : bool
close (pgplot) or 'show' (matplotlib) the plot at the end (or not, to allow
you to plot something else, use a cursor etc). In the case of pgplot, this also
implies opening the plot at the start, i.e. a self-contained quick plot.
x1 : float
left-hand plot limit. Defaults to 0.5
x2 : float
right-hand plot limit. Defaults to nxmax+0.5
y1 : float
lower plot limit. Defaults to 0.5
y2 : float
upper plot limit. Defaults to nymax+0.5
sepmin : float
minimum separation between intensity limits (> 0 to stop PGPLOT complaining)
:Returns:
range(s) : tuple or list
the plot range(s) used either as a single 2-element tuple, or
a list of them, one per CCD plotted.
"""
if nc == -1:
nc1 = 0
nc2 = len(self)
else:
nc1 = nc
nc2 = nc+1
if not mpl:
if close: pg.pgopen('/xs')
if nc2-nc1 > 1: pg.pgsubp(nc2-nc1,1)
prange = []
for nc, ccd in enumerate(self._data[nc1:nc2]):
# Determine intensity range to display
if method == 'p':
vmin, vmax = ccd.centile((vlo,vhi))
elif method == 'a':
vmin, vmax = ccd.min(), ccd.max()
elif method == 'd':
vmin, vmax = vlo, vhi
else:
raise UltracamError('MCCD.plot: method must be one of p, a or d.')
if vmin == vmax:
vmin -= sepmin/2.
vmax += sepmin/2.
prange.append((vmin, vmax))
# start
nxmax, nymax = ccd.nxmax, ccd.nymax
x1 = 0.5 if x1 is None else x1
x2 = nxmax+0.5 if x2 is None else x2
y1 = 0.5 if y1 is None else y1
y2 = nymax+0.5 if y2 is None else y2
if mpl:
if nc2-nc1 > 1:
plt.subplot(1,nc2-nc1,nc+1)
plt.axis('equal')
else:
if nc2-nc1 > 1: pg.pgpanl(nc-nc1+1,1)
pg.pgwnad(x1,x2,y1,y2)
# plot CCD
ccd.plot(vmin,vmax,mpl,cmap)
# per-frame finishing-off
if mpl:
plt.xlim(x1,x2)
plt.ylim(y1,y2)
else:
pg.pgbox('bcnst',0,0,'bcnst',0,0)
pg.pglab('X','Y','')
if close:
if mpl:
plt.show()
else:
pg.pgclos()
# return intensity range(s) used
if len(prange) == 1:
return prange[0]
else:
return tuple(prange)
shortYArray = [xPosition]
ppgplot.pgsci(2)
ppgplot.pgpanl(1, panel + 1)
ppgplot.pgpt(shortXArray, shortYArray, 1)
ppgplot.pgsci(3)
shortYArray = [yPosition]
ppgplot.pgpt(shortXArray, shortYArray, 1)
if arg.sleep!=0:
time.sleep(arg.sleep)
sys.stdout.write("\rProcessed %d frames \n"%frameRange)
sys.stdout.flush()
if arg.preview:
ppgplot.pgslct(bitmapView['pgplotHandle'])
ppgplot.pgclos()
if watch!=-1:
ppgplot.pgslct(watchView['pgplotHandle'])
ppgplot.pgclos()
# Fit polynomials to the positions of the reference apertures
for p, referenceAperture in enumerate(referenceApertures.getSources()):
xValues = [log['frameNumber'] for log in referenceAperture.positionLog]
yValues = [log['position'][0] - referenceAperture.position[0] for log in referenceAperture.positionLog]
polynomial = numpy.polyfit(xValues, yValues, polynomialDegree)
# Draw the polynomial
ppgplot.pgslct(xyPositionPlot['pgplotHandle'])
ppgplot.pgsci(2)
ppgplot.pgpanl(1, p + 1)
ylimits = (0, ylimits[1] + abs(ylimits[0]))
if ylimits[1] > height:
ylimits = (height - newHeight, height)
xlimits = (int(xlimits[0]), int(xlimits[1]))
ylimits = (int(ylimits[0]), int(ylimits[1]))
print("new limits:", xlimits, ylimits)
ra_limits, dec_limits = wcsSolution.all_pix2world(
numpy.array(xlimits), numpy.array(ylimits), 1)
margins = [[ra_limits[0], dec_limits[0]],
[ra_limits[1], dec_limits[1]]]
print("new limits (world)", ra_limits, dec_limits)
ppgplot.pgswin(xlimits[0], xlimits[1], ylimits[0], ylimits[1])
redraw()
if plotSources: sourceStatus = "ON"
else: sourceStatus = "OFF"
if plotHa: HaStatus = "ON"
else: HaStatus = "OFF"
if invertedColours: invertStatus = "ON"
else: invertStatus = "OFF"
print(
"Filter: %s PlotSources[%s] Plot Ha extended[%s] Invert Greyscale[%s]"
% (filter, sourceStatus, HaStatus, invertStatus))
# except KeyboardInterrupt:
# print "Ctrl-C pressed, but I dealt with it. "
ppgplot.pgclos()
def main(options):
debug = options.debug
MSlist = []
for inmspart in options.inms.split(','):
for msname in glob.iglob(inmspart):
MSlist.append(msname)
if len(MSlist) == 0:
print 'Error: You must specify at least one MS name.'
print ' Use "uvplot.py -h" to get help.'
return
if len(MSlist) > 1:
print 'WARNING: Antenna selection (other than all) may not work well'
print ' when plotting more than one MS. Carefully inspect the'
print ' listings of antenna numbers/names!'
device = options.device
if device=='?':
ppgplot.pgldev()
return
if options.title == '':
plottitle = options.inms
else:
plottitle = options.title
axlimits = options.axlimits.split(',')
if len(axlimits) == 4:
xmin,xmax,ymin,ymax = axlimits
else:
print 'Error: You must specify four axis limits'
return
timeslots = options.timeslots.split(',')
if len(timeslots) != 3:
print 'Error: Timeslots format is start,skip,end'
return
for i in range(len(timeslots)):
timeslots[i] = int(timeslots[i])
if timeslots[i] < 0:
print 'Error: timeslots values must not be negative'
return
antToPlotSpl = options.antennas.split(',')
antToPlot = []
for i in range(len(antToPlotSpl)):
tmpspl = antToPlotSpl[i].split('..')
if len(tmpspl) == 1:
antToPlot.append(int(antToPlotSpl[i]))
elif len(tmpspl) == 2:
for j in range(int(tmpspl[0]),int(tmpspl[1])+1):
antToPlot.append(j)
else:
print 'Error: Could not understand antenna list.'
return
queryMode = options.query
plotLambda = options.kilolambda
badval = 0.0
xaxisvals = numpy.array([])
yaxisvals = numpy.array([])
savex = numpy.array([])
savey = numpy.array([])
numPlotted = 0
for inputMS in MSlist:
# open the main table and print some info about the MS
print 'Getting info for', inputMS
t = pt.table(inputMS, readonly=True, ack=False)
tfreq = pt.table(t.getkeyword('SPECTRAL_WINDOW'),readonly=True,ack=False)
ref_freq = tfreq.getcol('REF_FREQUENCY',nrow=1)[0]
ch_freq = tfreq.getcol('CHAN_FREQ',nrow=1)[0]
print 'Reference frequency:\t%f MHz' % (ref_freq/1.e6)
if options.wideband:
ref_wavelength = 2.99792458e8/ch_freq
else:
ref_wavelength = [2.99792458e8/ref_freq]
print 'Reference wavelength:\t%f m' % (ref_wavelength[0])
if options.sameuv and numPlotted > 0:
print 'Assuming same uvw as first MS!'
if plotLambda:
for w in ref_wavelength:
xaxisvals = numpy.append(xaxisvals,[savex/w/1000.,-savex/w/1000.])
yaxisvals = numpy.append(yaxisvals,[savey/w/1000.,-savey/w/1000.])
else:
print 'Plotting more than one MS with same uv, all in meters... do you want -k?'
xaxisvals = numpy.append(xaxisvals,[savex,-savex])
yaxisvals = numpy.append(yaxisvals,[savey,-savey])
continue
firstTime = t.getcell("TIME", 0)
lastTime = t.getcell("TIME", t.nrows()-1)
intTime = t.getcell("INTERVAL", 0)
print 'Integration time:\t%f sec' % (intTime)
nTimeslots = (lastTime - firstTime) / intTime
print 'Number of timeslots:\t%d' % (nTimeslots)
if timeslots[1] == 0:
if nTimeslots >= 100:
timeskip = int(nTimeslots/100)
else:
timeskip = 1
else:
timeskip = int(timeslots[1])
print 'For each baseline, plotting one point every %d samples' % (timeskip)
if timeslots[2] == 0:
timeslots[2] = nTimeslots
# open the antenna subtable
tant = pt.table(t.getkeyword('ANTENNA'), readonly=True, ack=False)
# Station names
antList = tant.getcol('NAME')
if len(antToPlot)==1 and antToPlot[0]==-1:
antToPlot = range(len(antList))
print 'Station list (only starred stations will be plotted):'
for i in range(len(antList)):
star = ' '
if i in antToPlot: star = '*'
print '%s %2d\t%s' % (star, i, antList[i])
# Bail if we're in query mode
if queryMode:
return
# select by time from the beginning, and only use specified antennas
tsel = t.query('TIME >= %f AND TIME <= %f AND ANTENNA1 IN %s AND ANTENNA2 IN %s' % (firstTime+timeslots[0]*intTime,firstTime+timeslots[2]*intTime,str(antToPlot),str(antToPlot)), columns='ANTENNA1,ANTENNA2,UVW')
# Now we loop through the baselines
i = 0
nb = (len(antToPlot)*(len(antToPlot)-1))/2
sys.stdout.write('Reading uvw for %d baselines: %04d/%04d'%(nb,i,nb))
sys.stdout.flush()
for tpart in tsel.iter(["ANTENNA1","ANTENNA2"]):
ant1 = tpart.getcell("ANTENNA1", 0)
ant2 = tpart.getcell("ANTENNA2", 0)
if ant1 not in antToPlot or ant2 not in antToPlot: continue
if ant1 == ant2: continue
i += 1
sys.stdout.write('\b\b\b\b\b\b\b\b\b%04d/%04d'%(i,nb))
sys.stdout.flush()
# Get the values to plot
uvw = tpart.getcol('UVW', rowincr=timeskip)
if numPlotted == 0:
savex = numpy.append(savex,[uvw[:,0],-uvw[:,0]])
savey = numpy.append(savey,[uvw[:,1],-uvw[:,1]])
if plotLambda:
for w in ref_wavelength:
xaxisvals = numpy.append(xaxisvals,[uvw[:,0]/w/1000.,-uvw[:,0]/w/1000.])
yaxisvals = numpy.append(yaxisvals,[uvw[:,1]/w/1000.,-uvw[:,1]/w/1000.])
else:
xaxisvals = numpy.append(xaxisvals,[uvw[:,0],-uvw[:,0]])
yaxisvals = numpy.append(yaxisvals,[uvw[:,1],-uvw[:,1]])
#if debug:
# print uvw.shape
# print xaxisvals.shape
# print yaxisvals.shape
#else:
# sys.stdout.write('.')
# sys.stdout.flush()
sys.stdout.write(' Done!\n')
numPlotted += 1
print 'Plotting uv points ...'
# open the graphics device, using only one panel
ppgplot.pgbeg(device, 1, 1)
# set the font size
ppgplot.pgsch(1)
ppgplot.pgvstd()
# Plot the data
if debug:
print xaxisvals
xaxisvals = numpy.array(xaxisvals)
yaxisvals = numpy.array(yaxisvals)
tmpvals = numpy.sqrt(xaxisvals**2+yaxisvals**2)
ppgplot.pgsci(1)
uvmax = max(xaxisvals.max(),yaxisvals.max())
uvmin = min(xaxisvals.min(),yaxisvals.min())
uvuplim = 0.02*(uvmax-uvmin)+uvmax
uvlolim = uvmin-0.02*(uvmax-uvmin)
if xmin == '':
minx = uvlolim
else:
minx = float(xmin)
if xmax == '':
maxx = uvuplim
else:
maxx = float(xmax)
if ymin == '':
miny = uvlolim
else:
miny = float(ymin)
if ymax == '':
maxy = uvuplim
else:
maxy = float(ymax)
if minx == maxx:
minx = -1.0
maxx = 1.0
if miny == maxy:
miny = -1.0
maxy = 1.0
ppgplot.pgpage()
ppgplot.pgswin(minx,maxx,miny,maxy)
ppgplot.pgbox('BCNST',0.0,0,'BCNST',0.0,0)
if plotLambda:
ppgplot.pglab('u [k\gl]', 'v [k\gl]', '%s'%(plottitle))
else:
ppgplot.pglab('u [m]', 'v [m]', '%s'%(plottitle))
ppgplot.pgpt(xaxisvals[tmpvals!=badval], yaxisvals[tmpvals!=badval], 1)
# Close the PGPLOT device
ppgplot.pgclos()
def plot(self, vlo=2., vhi=98., nc=-1, method='p', mpl=False, cmap=CMDEF, \
close=True, x1=None, x2=None, y1=None, y2=None, sepmin=1.):
"""
Plots an MCCD using pgplot or matplotlib if preferred.
:Parameters:
vlo : float
number specifying the lowest level to plot (default as a percentile)
vhi : float
number specifying the lowest level to plot (default as a percentile)
nc : int
CCD number (starting from 0, -1 for all)
method : string
how vlo and vhi are to be interpreted. 'p' = percentile, 'a' = automatic (min to max,
vlo and vhi are irrelevant), 'd' = direct, i.e. just take the values given.
mpl : bool
True to prefer matplotlib over pgplot (which may not even be an option)
cmap : matplotlib.cm.binary
colour map if using matplotlib
close : bool
close (pgplot) or 'show' (matplotlib) the plot at the end (or not, to allow
you to plot something else, use a cursor etc). In the case of pgplot, this also
implies opening the plot at the start, i.e. a self-contained quick plot.
x1 : float
left-hand plot limit. Defaults to 0.5
x2 : float
right-hand plot limit. Defaults to nxmax+0.5
y1 : float
lower plot limit. Defaults to 0.5
y2 : float
upper plot limit. Defaults to nymax+0.5
sepmin : float
minimum separation between intensity limits (> 0 to stop PGPLOT complaining)
:Returns:
range(s) : tuple or list
the plot range(s) used either as a single 2-element tuple, or
a list of them, one per CCD plotted.
"""
if nc == -1:
nc1 = 0
nc2 = len(self)
else:
nc1 = nc
nc2 = nc + 1
if not mpl:
if close: pg.pgopen('/xs')
if nc2 - nc1 > 1: pg.pgsubp(nc2 - nc1, 1)
prange = []
for nc, ccd in enumerate(self._data[nc1:nc2]):
# Determine intensity range to display
if method == 'p':
vmin, vmax = ccd.centile((vlo, vhi))
elif method == 'a':
vmin, vmax = ccd.min(), ccd.max()
elif method == 'd':
vmin, vmax = vlo, vhi
else:
raise UltracamError(
'MCCD.plot: method must be one of p, a or d.')
if vmin == vmax:
vmin -= sepmin / 2.
vmax += sepmin / 2.
prange.append((vmin, vmax))
# start
nxmax, nymax = ccd.nxmax, ccd.nymax
x1 = 0.5 if x1 is None else x1
x2 = nxmax + 0.5 if x2 is None else x2
y1 = 0.5 if y1 is None else y1
y2 = nymax + 0.5 if y2 is None else y2
if mpl:
if nc2 - nc1 > 1:
plt.subplot(1, nc2 - nc1, nc + 1)
plt.axis('equal')
else:
if nc2 - nc1 > 1: pg.pgpanl(nc - nc1 + 1, 1)
pg.pgwnad(x1, x2, y1, y2)
# plot CCD
ccd.plot(vmin, vmax, mpl, cmap)
# per-frame finishing-off
if mpl:
plt.xlim(x1, x2)
plt.ylim(y1, y2)
else:
pg.pgbox('bcnst', 0, 0, 'bcnst', 0, 0)
pg.pglab('X', 'Y', '')
if close:
if mpl:
plt.show()
else:
pg.pgclos()
# return intensity range(s) used
if len(prange) == 1:
return prange[0]
else:
return tuple(prange)
