def plotgal(xg,yg,final,finalsf,ncl):
ppgplot.pgslw(6)
ppgplot.pgsls(1)
xmin = (-1.*c.pscale[ncl]*(c.xc[ncl]-1))
xmax = (c.pscale[ncl]*(c.xmax[ncl]-c.xc[ncl]))
ymin = (-1.*c.pscale[ncl]*(c.yc[ncl]-1))
ymax = (c.pscale[ncl]*(c.ymax[ncl]-c.yc[ncl]))
ppgplot.pgbox("",0.0,0,"L",0.0,0)
dx=5.
ppgplot.pgenv(xmin-dx,xmax+dx,ymin-dx,ymax+dx,0)
ppgplot.pglab("\gD DEC (\")","\gD RA (\")","")
ppgplot.pgtext(-4,-4,"X")
r = (0.5*c.r200pix[ncl]*c.pscale[ncl])
ppgplot.pgslw(1)
ppgplot.pgsls(2)
ppgplot.pgsfs(2)
ppgplot.pgcirc(0,0,r)
#print "cluster ",ncl," r200: ",c.r200pix[ncl],c.r200Mpc[ncl], " Mpc"
ppgplot.pgslw(3)
ppgplot.pgsls(1)
x = (xg - c.xc[ncl])*c.pscale[ncl]
y = (yg - c.yc[ncl])*c.pscale[ncl]
x = (N.compress((final > 0) & (finalsf < 1), xg) - c.xc[ncl])*c.pscale[ncl]
y = (N.compress((final > 0) & (finalsf < 1), yg) - c.yc[ncl])*c.pscale[ncl]
ppgplot.pgpt(x,y,22)
x = (N.compress((final > 0) & (finalsf > 0), xg) - c.xc[ncl])*c.pscale[ncl]
y = (N.compress((final > 0) & (finalsf > 0), yg) - c.yc[ncl])*c.pscale[ncl]
ppgplot.pgpt(x,y,18)
def plot_header(fname, ff, iod_line):
# ppgplot arrays
heat_l = np.array([0.0, 0.2, 0.4, 0.6, 1.0])
heat_r = np.array([0.0, 0.5, 1.0, 1.0, 1.0])
heat_g = np.array([0.0, 0.0, 0.5, 1.0, 1.0])
heat_b = np.array([0.0, 0.0, 0.0, 0.3, 1.0])
# Plot
ppg.pgopen(fname)
ppg.pgpap(0.0, 1.0)
ppg.pgsvp(0.1, 0.95, 0.1, 0.8)
ppg.pgsch(0.8)
ppg.pgmtxt("T", 6.0, 0.0, 0.0,
"UT Date: %.23s COSPAR ID: %04d" % (ff.nfd, ff.site_id))
if is_calibrated(ff):
ppg.pgsci(1)
else:
ppg.pgsci(2)
ppg.pgmtxt(
"T", 4.8, 0.0, 0.0, "R.A.: %10.5f (%4.1f'') Decl.: %10.5f (%4.1f'')" %
(ff.crval[0], 3600.0 * ff.crres[0], ff.crval[1], 3600.0 * ff.crres[1]))
ppg.pgsci(1)
ppg.pgmtxt("T", 3.6, 0.0, 0.0, ("FoV: %.2f\\(2218)x%.2f\\(2218) "
"Scale: %.2f''x%.2f'' pix\\u-1\\d") %
(ff.wx, ff.wy, 3600.0 * ff.sx, 3600.0 * ff.sy))
ppg.pgmtxt(
"T", 2.4, 0.0, 0.0, "Stat: %5.1f+-%.1f (%.1f-%.1f)" %
(np.mean(ff.zmax), np.std(ff.zmax), ff.zmaxmin, ff.zmaxmax))
ppg.pgmtxt("T", 0.3, 0.0, 0.0, iod_line)
ppg.pgsch(1.0)
ppg.pgwnad(0.0, ff.nx, 0.0, ff.ny)
ppg.pglab("x (pix)", "y (pix)", " ")
ppg.pgctab(heat_l, heat_r, heat_g, heat_b, 5, 1.0, 0.5)
def plotsigsff(sig, sf, file, nbin):
psplot = file + ".ps"
psplotinit(psplot)
tot = N.ones(len(sf), 'f')
(sigbin, sfbin) = my.binitsumequal(sig, sf, nbin)
(sigbin, totbin) = my.binitsumequal(sig, tot, nbin)
print sfbin
print totbin
(sff, sfferr) = my.ratioerror(sfbin, totbin)
ppgplot.pgbox("", 0.0, 0, "L", 0.0, 0)
ymin = -.05
ymax = 1.05
xmin = min(sig) - 10.
#xmax=max(sig)-200.
xmax = 350.
ppgplot.pgenv(xmin, xmax, ymin, ymax, 0)
ppgplot.pglab("\gS\d5\u (gal/Mpc\u2\d)", "Fraction EW([OII])>4 \(2078)",
"")
ppgplot.pgsls(1) #dotted
ppgplot.pgslw(4) #line width
sig = N.array(sig, 'f')
sff = N.array(sff, 'f')
ppgplot.pgsci(2)
ppgplot.pgline(sigbin, sff)
ppgplot.pgsci(1)
ppgplot.pgpt(sigbin, sff, 17)
my.errory(sigbin, sff, sfferr)
ppgplot.pgend()
def getChiSqByParameters(params, *args):
global iteration, mainPlotWindow, currentPlotWindow, colour, inclination, phase
print "Params:", params
beta = params[0]
log_lambda = params[1]
scale_factor = params[2]
linear_offset = params[3]
print "Args:", args
temperature = args[0]
field = args[1]
# cos(theta) = cos(i)cos(beta) - sin(i)sin(beta)cos(phi + pi/2)
cosTheta = math.cos(radians(inclination)) * math.cos(radians(beta)) - math.sin(radians(inclination)) * math.sin(radians(beta))*math.cos(phase + math.pi/2.)
angle = math.acos(cosTheta) / math.pi * 180
print "Angle: %f [deg], Field: %f [MG], Temperature:%f [keV], log_lambda: %f, scale: %f, offset: %f"%(angle, field, temperature, log_lambda, scale_factor, linear_offset)
model = getSampledModel(observedSpectrum.wavelengths, angle, field, temperature, log_lambda)
model = [m * scale_factor + linear_offset for m in model]
chi = computeChiSq(observedSpectrum, model)
allChiSqs.append(chi)
print "Chi-squared:", chi
startWavelength = min(observedSpectrum.wavelengths)
endWavelength = max(observedSpectrum.wavelengths)
# Draw the most recent iteration
ppgplot.pgslct(currentPlotWindow)
ppgplot.pgsci(1)
ppgplot.pgenv(startWavelength, endWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgline(observedSpectrum.wavelengths, observedSpectrum.flux)
ppgplot.pgsci(4)
ppgplot.pgline(observedSpectrum.wavelengths, model)
ppgplot.pgsci(1)
ppgplot.pglab("wavelength", "flux", "Current fit: %d"%iteration)
# Overplot the iteration on the original diagram
print "overplotting"
ppgplot.pgslct(mainPlotWindow)
ppgplot.pgsci(colour)
ppgplot.pgline(observedSpectrum.wavelengths, model)
colour += 1
if colour>15: colour = 1
ppgplot.pgsci(1)
# Re-generate the Chi-Squared plot
ppgplot.pgslct(chiSqPlotWindow)
if iteration > 9:
ppgplot.pgenv(0, iteration+1, 0, max(allChiSqs), 0, 0)
else:
ppgplot.pgenv(0, 10, 0, max(allChiSqs), 0, 0)
iterations = range(iteration+1)
ppgplot.pgpt(iterations, allChiSqs, 2)
minCh = min(allChiSqs)
medCh = numpy.median(allChiSqs)
maxCh = max(allChiSqs)
ppgplot.pglab("Iteration [n]", "Chi-squared", "Chi-squared values [%.2f, %.2f, %.2f]"%(minCh, medCh, maxCh))
iteration += 1
return chi
def xysimple(x, y, xlabel, ylabel):
xmax = max(x)
xmin = min(x)
ymax = max(y)
ymin = min(y)
ppgplot.pgbox("", 0.0, 0, "", 0.0, 0)
ppgplot.pgenv(xmin, xmax, ymin, ymax, 0)
ppgplot.pglab(xlabel, ylabel, "")
ppgplot.pgpt(x, y, 3)
def terminatePlot(self):
if not self.plotDeviceIsOpened:
raise ValueError("You have not yet opened a PGPLOT device.")
if self._drawBox:
pgplot.pgsci(1)
pgplot.pgbox(self._xAxisOptions, 0.0, 0, self._yAxisOptions, 0.0,
0)
pgplot.pglab(self.xLabel, self.yLabel, self.title)
pgplot.pgend()
self.plotDeviceIsOpened = False
def plotold():
xmin=2.2
xmax=3.2
ymin=-2.5
ymax=-.5
psplotinit('fSsigma3Gyr.ps')
ppgplot.pgbox("",0.0,0,"",0.0,0)
ppgplot.pgenv(xmin,xmax,ymin,ymax,0,30)
ppgplot.pglab("\gs (km/s)",'fS(10\u11\d:10\u13\d)',"")
ppgplot.pgsci(1)
ppgplot.pgline(sigma,frac)
ppgplot.pgsls(2)
ppgplot.pgsci(2)
ppgplot.pgline(sigma08,frac08)
ppgplot.pgsls(1)
ppgplot.pgsci(1)
ppgplot.pgend()
xmin=2.2
xmax=3.2
ymin=11.
ymax=14.2
psplotinit('maccretsigma3Gyr.ps')
ppgplot.pgbox("",0.0,0,"",0.0,0)
ppgplot.pgenv(xmin,xmax,ymin,ymax,0,30)
ppgplot.pglab("\gs (km/s)",'M\dacc\u (M\d\(2281)\u)',"")
ppgplot.pgsci(1)
ppgplot.pgline(sigma,maccret)
ppgplot.pgsls(2)
ppgplot.pgsci(2)
ppgplot.pgline(sigma08,maccret08)
ppgplot.pgsls(1)
ppgplot.pgsci(1)
mylines=N.arange(-20.,20.,.4)
mylineswidth=3
ppgplot.pgsls(4)
ppgplot.pgslw(mylineswidth)
x=N.arange(0.,5.,1.)
lines=mylines
for y0 in lines:
y=3*x +y0
ppgplot.pgline(x,y)
ppgplot.pgsls(1)
ppgplot.pgend()
os.system('cp maccretsigma.ps /Users/rfinn/SDSS/paper/.')
os.system('cp fSsigma.ps /Users/rfinn/SDSS/paper/.')
def makeplot():
psplotinit("noise.ps")
DATAMIN = 0.
DATAMAX = 15.
ppgplot.pgbox("", 0.0, 0, "L", 0.0, 0)
#print "making graph, ncl = ",ncl
path = os.getcwd()
f = path.split('/')
#print path
#print f
prefix = f[4]
title = prefix
ymin = -.05
ymax = max(aveaperr) + .1
#ymax=10.
ppgplot.pgenv(DATAMIN, DATAMAX, ymin, ymax, 0)
ppgplot.pglab("linear size N of aperture (pixel)", "rms in Sky (ADU/s)",
title)
ppgplot.pgsci(2) #red
ppgplot.pgslw(4) #line width
x = N.sqrt(avearea)
y = aveaperr
ppgplot.pgpt(x, y, 7)
#errory(x,y,erry)
ppgplot.pgsci(1) #black
#ppgplot.pgpt(isoarea,fluxerriso,3)
#x1=N.sqrt(contsubisoarea)
#y1=contsuberr
#x1=N.sqrt(isoarea)
#y1=fluxerriso
#y=n*y1
#ppgplot.pgpt(x1,y1,1)
#ppgplot.pgsci(4)#blue
#ppgplot.pgpt(x1,y,1)
#ppgplot.pgsci(1)#black
x = N.arange(0, 50, 1)
y = x * (a + b * a * x)
#y=N.sqrt(x)*.02
ppgplot.pgline(x, y)
#errory(x,y,erry)
ppgplot.pgend()
def plotsig10sffall(sigspec, sigphot, sf, file, nbin):
psplot = file + ".ps"
psplotinit(psplot)
ppgplot.pgbox("", 0.0, 0, "L", 0.0, 0)
ymin = -.01
ymax = 1.01
#xmin=min(sigspec)-10.
#xmax=max(sig)-200.
#xmax=400.
xmin = -1.
xmax = 2.7
ppgplot.pgenv(xmin, xmax, ymin, ymax, 0, 10)
ppgplot.pglab("\gS\d10\u (gal/Mpc\u2\d)", "Fraction EW([OII])>4 \(2078)",
"")
ppgplot.pgsls(1) #dotted
ppgplot.pgslw(4) #line width
tot = N.ones(len(sf), 'f')
(sigbin, sfbin) = my.binitsumequal(sigspec, sf, nbin)
(sigbin, totbin) = my.binitsumequal(sigspec, tot, nbin)
(sff, sfferr) = my.ratioerror(sfbin, totbin)
#sig=N.array(sig,'f')
#sff=N.array(sff,'f')
ppgplot.pgsci(2)
sigbin = N.log10(sigbin)
ppgplot.pgline(sigbin, sff)
ppgplot.pgsci(1)
ppgplot.pgpt(sigbin, sff, 17)
my.errory(sigbin, sff, sfferr)
(sigbin, sfbin) = my.binitsumequal(sigphot, sf, nbin)
(sigbin, totbin) = my.binitsumequal(sigphot, tot, nbin)
(sff, sfferr) = my.ratioerror(sfbin, totbin)
#sig=N.array(sig,'f')
#sff=N.array(sff,'f')
ppgplot.pgslw(4) #line width
ppgplot.pgsci(4)
sigbin = N.log10(sigbin)
ppgplot.pgline(sigbin, sff)
ppgplot.pgsci(1)
ppgplot.pgpt(sigbin, sff, 21)
#my.errory(sigbin,sff,sfferr)
ppgplot.pgend()
def compdiff(x, y, xlabel, ylabel):
xmax = max(x)
xmin = min(x)
ymax = max(y)
ymin = min(y)
ave = N.average(N.compress((x < 21) & (im1.sn > 3), y))
std = scipy.stats.std(N.compress((x < 21) & (im1.sn > 3), y))
ppgplot.pgbox("", 0.0, 0, "", 0.0, 0)
ppgplot.pgenv(xmin, xmax, -.8, .8, 0)
ppgplot.pglab(xlabel, ylabel, "")
ppgplot.pgpt(x, y, 3)
x = N.arange((int(xmin) - 1), (int(xmax) + 2), 1)
y = ave * x / x
ppgplot.pgsci(2)
ppgplot.pgline(x, y)
ppgplot.pgsci(1)
y1 = y - std
ppgplot.pgline(x, y1)
y1 = y + std
ppgplot.pgline(x, y1)
def plotoutlierpos():
dm = 0.01
xlabel = "x position of outliers"
ylabel = "y position of outliers"
delta = abs(im1.magap5 - im2.magap5)
x = N.compress(delta > dm, im1.x)
y = N.compress(delta > dm, im1.y)
xmax = max(x)
xmin = min(x)
ymax = max(y)
ymin = min(y)
ppgplot.pgbox("", 0.0, 0, "", 0.0, 0)
#ppgplot.pgenv(xmin,xmax,ymin,ymax,0)
ppgplot.pgenv(0, 920, 0, 875, 0)
ppgplot.pglab(xlabel, ylabel, "")
ppgplot.pgpt(x, y, 3)
x = N.compress(delta > dm, im2.x)
y = N.compress(delta > dm, im2.y)
diff = N.compress(delta > dm, delta)
ppgplot.pgpt(x, y, 4)
for i in range(len(x)):
print x[i], y[i], diff[i]
def plotsigo2(sig, o2, file, nbin):
psplot = file + ".ps"
psplotinit(psplot)
(sigbin, o2bin) = my.binit(sig, o2, nbin)
ppgplot.pgbox("", 0.0, 0, "L", 0.0, 0)
ymin = -10.
ymax = 2.
xmin = min(sig) - 10.
#xmax=max(sig)-200.
xmax = 350.
ppgplot.pgenv(xmin, xmax, ymin, ymax, 0)
ppgplot.pglab("\gS\d5\u (gal/Mpc\u2\d)", "EW([OII]) (\(2078))", "")
ppgplot.pgsls(1) #dotted
ppgplot.pgslw(4) #line width
sig = N.array(sig, 'f')
o2 = N.array(o2, 'f')
ppgplot.pgpt(sig, o2, 1)
ppgplot.pgsci(2)
ppgplot.pgline(sigbin, o2bin)
ppgplot.pgsci(1)
ppgplot.pgend()
#! /usr/bin/env python
#
# pgex1: freely taken after PGDEMO1.F
#
import ppgplot, numpy
import sys
# create an array
xs=numpy.array([1.,2.,3.,4.,5.])
ys=numpy.array([1.,4.,9.,16.,25.])
# creat another array
yr = 0.1*numpy.array(range(0,60))
xr = yr*yr
# pgplotting
if len(sys.argv) > 1: # if we got an argument use the argument as devicename
ppgplot.pgopen(sys.argv[1])
else:
ppgplot.pgopen('/xwin')
ppgplot.pgenv(0.,10.,0.,20.,0,1)
ppgplot.pglab('(x)', '(y)', 'PGPLOT Example 1: y = x\u2')
ppgplot.pgpt(xs,ys,9)
ppgplot.pgline(xr,yr)
ppgplot.pgclos()
########################
# PS OUTPUT
###############################################################
filename=sys.argv[1]
psfile = str(filename)+".ps" # print ("psfile\n")
ppgplot.pgbegin(0,"psfile/VCPS", 1, 1)
# pgbegin(0,"psfile/PS", 1, 1)
# Plot Setting
####################################################################
ppgplot.pgpaper(8,1.25) # window/paper size (width(inch), aspect)
ppgplot.pgscf(2) # characte font (1: normal, 2: roman, 3: italic, 4: script)
ppgplot.pgslw(3) # line width
ppgplot.pgsvp(0.15, 0.9, 0.53, 0.89) # viewport in the window (relative)
ppgplot.pglab("", "", "Local Time [hour]")
ppgplot.pgsvp(0.12, 0.9, 0.53, 0.88) # viewport in the window (relative)
ppgplot.pglabel("", "Airmass", "") # label settingoto s
ppgplot.pgsch(1.0) # character height (size)
ppgplot.pgslw(3) # line width
ppgplot.pgsvp(0.15, 0.9, 0.53, 0.88) # viewport in the window (relative)
ppgplot.pgswin(t_min, t_max, a_max, a_min) # MIN,MAX of coordinate
ppgplot.pgbox('BCTS', 0.0, 0, 'BCTSNV1', 0.1, 0) # coordinate settings
ppgplot.pgbox('0', 0.0, 0, 'BCTSMV1', 0.1, 0) # coordinate settings
# Put Header/ Axes Label
#####################################################################
#####################################################################
# READ USER INPUT
mainPGPlotWindow = ppgplot.pgopen(plotDevice) pgPlotTransform = [0, 1, 0, 0, 0, 1] ppgplot.pgpap(10, 0.618) ppgplot.pgsci(1) ppgplot.pgenv(min(x_values), max(x_values), yLims[0], yLims[1], 0, 0) ppgplot.pgslw(7) ppgplot.pgpt(x_values, y_values, 1) ppgplot.pgslw(1) ppgplot.pgerrb(2, x_values, y_values, y_errors, 0) ppgplot.pgerrb(4, x_values, y_values, y_errors, 0) ppgplot.pgsls(2) ppgplot.pgline(xFit, yFit) ppgplot.pgsls(3) ppgplot.pgline([a3, a3], [yLims[0], yLims[1]]) ppgplot.pgsls(1) ppgplot.pglab(xColumn + " - " + str(JDoffset), "flux ratio", "") ppgplot.pgclos() time.sleep(3) times = [] sharpness = [] random.seed() for n in range(arg.iterations): # Give all the points a random bump... y_perturbed = [] for y, y_error in zip(y_values, y_errors): y_p = numpy.random.normal(y, y_error) y_perturbed.append(y_p) y_perturbed = numpy.array(y_perturbed) # Trim off a few points from each end of the data. leftTrim = random.randrange(0, trimSize)
angleArray = []
# Plot theta as a function of orbital phase for these parameters
for phase in numpy.arange(0.5, 1.51, 0.01):
theta = computeViewingAngle(phase, inclination, beta, phi)
phaseArray.append(phase)
angleArray.append(theta)
mainPlotWindow = ppgplot.pgopen("/xs")
ppgplot.pgask(False)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgsci(1)
ppgplot.pgenv(min(phaseArray), max(phaseArray), 0, 180, 0, 0)
ppgplot.pgline(phaseArray, angleArray)
ppgplot.pgsls(2)
ppgplot.pgline([0.5, 1.5], [90, 90])
ppgplot.pglab("orbital phase", "viewing angle",
"Viewing angle \gh as a function of orbital phase.")
ppgplot.pgtext(0.6, 150,
"i:%2.0f \gb:%2.0f \gf:%2.0f" % (inclination, beta, phi))
modelPlotWindow = ppgplot.pgopen("models_i_81_b_40.ps/ps")
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgask(False)
mainFluxMax = 0
mainFluxMin = 1E99
for phase in numpy.arange(0.5, 1.6, 0.1):
ppgplot.pgsci(1)
theta = computeViewingAngle(phase, inclination, beta, phi)
intensities = ["i", "i_0", "i_1"]
lineStyles = [1, 2, 3]
if maxSources<1:
debug.write("WARNING: Not enough sources for shift calculation, proceeding in '--noshift' mode.", 1)
applyShift = False
else:
topSources = allSources[0:maxSources]
masterApertureList = [ (x, y) for (x, y, flux) in topSources]
# Plot the preview frame
if (arg.keyimages):
#stackedFigure = matplotlib.pyplot.figure(figsize=(10, 10))
#matplotlib.pyplot.title("Initial 10 frame stacked image")
stackedPreview = ppgplot.pgopen('/xs')
ppgplot.pgenv(0.,fullFramexsize,0.,fullFrameysize, 1, 0)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pglab("x", "y", "Initial 10 frame stacked image.")
# Display the image on the user's screen
image = matplotlib.pyplot.imshow(boostedFullFrame, cmap='gray_r')
for s in allSources:
x, y = s[0], s[1]
matplotlib.pyplot.gca().add_artist(matplotlib.pyplot.Circle((x,y), 10, color='green', fill=False, linewidth=1.0))
if applyShift:
for s in topSources:
x, y = s[0], s[1]
matplotlib.pyplot.gca().add_artist(matplotlib.pyplot.Circle((x,y), 10, color='blue', fill=False, linewidth=1.0))
rows, cols = numpy.shape(boostedFullFrame)
ppgplot.pggray(boostedFullFrame, 0, cols-1, 0, rows-1, 0, 255, pgPlotTransform)
ppgplot.pgsfs(2) # Set fill style to 'outline'
ppgplot.pgsci(3) # Set the colour to 'green'
# /usr/bin/env python
#
# pgex1: freely taken after PGDEMO1.F
#
import ppgplot, Numeric
import sys
# create an array
xs = Numeric.array([1.0, 2.0, 3.0, 4.0, 5.0])
ys = Numeric.array([1.0, 4.0, 9.0, 16.0, 25.0])
# creat another array
yr = 0.1 * Numeric.array(range(0, 60))
xr = yr * yr
# pgplotting
if len(sys.argv) > 1: # if we got an argument use the argument as devicename
ppgplot.pgopen(sys.argv[1])
else:
ppgplot.pgopen("?")
ppgplot.pgenv(0.0, 10.0, 0.0, 20.0, 0, 1)
ppgplot.pglab("(x)", "(y)", "PGPLOT Example 1: y = x\u2")
ppgplot.pgpt(xs, ys, 9)
ppgplot.pgline(xr, yr)
ppgplot.pgclos()
def extract_tracks(fname, trkrmin, drdtmin, trksig, ntrkmin):
# Read four frame
ff = fourframe(fname)
# Skip saturated frames
if np.sum(ff.zavg > 240.0) / float(ff.nx * ff.ny) > 0.95:
return
# Read satelite IDs
try:
f = open(fname + ".id")
except OSError:
print("Cannot open", fname + ".id")
else:
lines = f.readlines()
f.close()
# ppgplot arrays
tr = np.array([-0.5, 1.0, 0.0, -0.5, 0.0, 1.0])
heat_l = np.array([0.0, 0.2, 0.4, 0.6, 1.0])
heat_r = np.array([0.0, 0.5, 1.0, 1.0, 1.0])
heat_g = np.array([0.0, 0.0, 0.5, 1.0, 1.0])
heat_b = np.array([0.0, 0.0, 0.0, 0.3, 1.0])
# Loop over identifications
for line in lines:
# Decode
id = satid(line)
# Skip slow moving objects
drdt = np.sqrt(id.dxdt**2 + id.dydt**2)
if drdt < drdtmin:
continue
# Extract significant pixels
x, y, t, sig = ff.significant(trksig, id.x0, id.y0, id.dxdt, id.dydt,
trkrmin)
# Fit tracks
if len(t) > ntrkmin:
# Get times
tmin = np.min(t)
tmax = np.max(t)
tmid = 0.5 * (tmax + tmin)
mjd = ff.mjd + tmid / 86400.0
# Skip if no variance in time
if np.std(t - tmid) == 0.0:
continue
# Very simple polynomial fit; no weighting, no cleaning
px = np.polyfit(t - tmid, x, 1)
py = np.polyfit(t - tmid, y, 1)
# Extract results
x0, y0 = px[1], py[1]
dxdt, dydt = px[0], py[0]
xmin = x0 + dxdt * (tmin - tmid)
ymin = y0 + dydt * (tmin - tmid)
xmax = x0 + dxdt * (tmax - tmid)
ymax = y0 + dydt * (tmax - tmid)
cospar = get_cospar(id.norad)
obs = observation(ff, mjd, x0, y0)
iod_line = "%s" % format_iod_line(id.norad, cospar, ff.site_id,
obs.nfd, obs.ra, obs.de)
print(iod_line)
if id.catalog.find("classfd.tle") > 0:
outfname = "classfd.dat"
elif id.catalog.find("inttles.tle") > 0:
outfname = "inttles.dat"
else:
outfname = "catalog.dat"
f = open(outfname, "a")
f.write("%s\n" % iod_line)
f.close()
# Plot
ppgplot.pgopen(
fname.replace(".fits", "") + "_%05d.png/png" % id.norad)
#ppgplot.pgopen("/xs")
ppgplot.pgpap(0.0, 1.0)
ppgplot.pgsvp(0.1, 0.95, 0.1, 0.8)
ppgplot.pgsch(0.8)
ppgplot.pgmtxt(
"T", 6.0, 0.0, 0.0,
"UT Date: %.23s COSPAR ID: %04d" % (ff.nfd, ff.site_id))
if (3600.0 * ff.crres[0] < 1e-3
) | (3600.0 * ff.crres[1] < 1e-3) | (
ff.crres[0] / ff.sx > 2.0) | (ff.crres[1] / ff.sy > 2.0):
ppgplot.pgsci(2)
else:
ppgplot.pgsci(1)
ppgplot.pgmtxt(
"T", 4.8, 0.0, 0.0,
"R.A.: %10.5f (%4.1f'') Decl.: %10.5f (%4.1f'')" %
(ff.crval[0], 3600.0 * ff.crres[0], ff.crval[1],
3600.0 * ff.crres[1]))
ppgplot.pgsci(1)
ppgplot.pgmtxt(
"T", 3.6, 0.0, 0.0,
"FoV: %.2f\\(2218)x%.2f\\(2218) Scale: %.2f''x%.2f'' pix\\u-1\\d"
% (ff.wx, ff.wy, 3600.0 * ff.sx, 3600.0 * ff.sy))
ppgplot.pgmtxt(
"T", 2.4, 0.0, 0.0, "Stat: %5.1f+-%.1f (%.1f-%.1f)" %
(np.mean(ff.zmax), np.std(ff.zmax), ff.vmin, ff.vmax))
ppgplot.pgmtxt("T", 0.3, 0.0, 0.0, iod_line)
ppgplot.pgsch(1.0)
ppgplot.pgwnad(0.0, ff.nx, 0.0, ff.ny)
ppgplot.pglab("x (pix)", "y (pix)", " ")
ppgplot.pgctab(heat_l, heat_r, heat_g, heat_b, 5, 1.0, 0.5)
ppgplot.pgimag(ff.zmax, ff.nx, ff.ny, 0, ff.nx - 1, 0, ff.ny - 1,
ff.vmax, ff.vmin, tr)
ppgplot.pgbox("BCTSNI", 0., 0, "BCTSNI", 0., 0)
ppgplot.pgstbg(1)
ppgplot.pgsci(0)
if id.catalog.find("classfd.tle") > 0:
ppgplot.pgsci(4)
elif id.catalog.find("inttles.tle") > 0:
ppgplot.pgsci(3)
ppgplot.pgpt(np.array([x0]), np.array([y0]), 4)
ppgplot.pgmove(xmin, ymin)
ppgplot.pgdraw(xmax, ymax)
ppgplot.pgsch(0.65)
ppgplot.pgtext(np.array([x0]), np.array([y0]), " %05d" % id.norad)
ppgplot.pgsch(1.0)
ppgplot.pgsci(1)
ppgplot.pgend()
elif id.catalog.find("classfd.tle") > 0:
# Track and stack
t = np.linspace(0.0, ff.texp)
x, y = id.x0 + id.dxdt * t, id.y0 + id.dydt * t
c = (x > 0) & (x < ff.nx) & (y > 0) & (y < ff.ny)
# Skip if no points selected
if np.sum(c) == 0:
continue
# Compute track
tmid = np.mean(t[c])
mjd = ff.mjd + tmid / 86400.0
xmid = id.x0 + id.dxdt * tmid
ymid = id.y0 + id.dydt * tmid
ztrk = ndimage.gaussian_filter(ff.track(id.dxdt, id.dydt, tmid),
1.0)
vmin = np.mean(ztrk) - 2.0 * np.std(ztrk)
vmax = np.mean(ztrk) + 6.0 * np.std(ztrk)
# Select region
xmin = int(xmid - 100)
xmax = int(xmid + 100)
ymin = int(ymid - 100)
ymax = int(ymid + 100)
if xmin < 0: xmin = 0
if ymin < 0: ymin = 0
if xmax > ff.nx: xmax = ff.nx - 1
if ymax > ff.ny: ymax = ff.ny - 1
# Find peak
x0, y0, w, sigma = peakfind(ztrk[ymin:ymax, xmin:xmax])
x0 += xmin
y0 += ymin
# Skip if peak is not significant
if sigma < trksig:
continue
# Skip if point is outside selection area
if inside_selection(id, xmid, ymid, x0, y0) == False:
continue
# Format IOD line
cospar = get_cospar(id.norad)
obs = observation(ff, mjd, x0, y0)
iod_line = "%s" % format_iod_line(id.norad, cospar, ff.site_id,
obs.nfd, obs.ra, obs.de)
print(iod_line)
if id.catalog.find("classfd.tle") > 0:
outfname = "classfd.dat"
elif id.catalog.find("inttles.tle") > 0:
outfname = "inttles.dat"
else:
outfname = "catalog.dat"
f = open(outfname, "a")
f.write("%s\n" % iod_line)
f.close()
# Plot
ppgplot.pgopen(
fname.replace(".fits", "") + "_%05d.png/png" % id.norad)
ppgplot.pgpap(0.0, 1.0)
ppgplot.pgsvp(0.1, 0.95, 0.1, 0.8)
ppgplot.pgsch(0.8)
ppgplot.pgmtxt(
"T", 6.0, 0.0, 0.0,
"UT Date: %.23s COSPAR ID: %04d" % (ff.nfd, ff.site_id))
ppgplot.pgmtxt(
"T", 4.8, 0.0, 0.0,
"R.A.: %10.5f (%4.1f'') Decl.: %10.5f (%4.1f'')" %
(ff.crval[0], 3600.0 * ff.crres[0], ff.crval[1],
3600.0 * ff.crres[1]))
ppgplot.pgmtxt(
"T", 3.6, 0.0, 0.0,
"FoV: %.2f\\(2218)x%.2f\\(2218) Scale: %.2f''x%.2f'' pix\\u-1\\d"
% (ff.wx, ff.wy, 3600.0 * ff.sx, 3600.0 * ff.sy))
ppgplot.pgmtxt(
"T", 2.4, 0.0, 0.0, "Stat: %5.1f+-%.1f (%.1f-%.1f)" %
(np.mean(ff.zmax), np.std(ff.zmax), ff.vmin, ff.vmax))
ppgplot.pgmtxt("T", 0.3, 0.0, 0.0, iod_line)
ppgplot.pgsch(1.0)
ppgplot.pgwnad(0.0, ff.nx, 0.0, ff.ny)
ppgplot.pglab("x (pix)", "y (pix)", " ")
ppgplot.pgctab(heat_l, heat_r, heat_g, heat_b, 5, 1.0, 0.5)
ppgplot.pgimag(ztrk, ff.nx, ff.ny, 0, ff.nx - 1, 0, ff.ny - 1,
vmax, vmin, tr)
ppgplot.pgbox("BCTSNI", 0., 0, "BCTSNI", 0., 0)
ppgplot.pgstbg(1)
plot_selection(id, xmid, ymid)
ppgplot.pgsci(0)
if id.catalog.find("classfd.tle") > 0:
ppgplot.pgsci(4)
elif id.catalog.find("inttles.tle") > 0:
ppgplot.pgsci(3)
ppgplot.pgpt(np.array([id.x0]), np.array([id.y0]), 17)
ppgplot.pgmove(id.x0, id.y0)
ppgplot.pgdraw(id.x1, id.y1)
ppgplot.pgpt(np.array([x0]), np.array([y0]), 4)
ppgplot.pgsch(0.65)
ppgplot.pgtext(np.array([id.x0]), np.array([id.y0]),
" %05d" % id.norad)
ppgplot.pgsch(1.0)
ppgplot.pgsci(1)
ppgplot.pgend()
ppgplot.pgask(False)
for index, o in enumerate(objects):
MJD = o.getColumn('MJD')
mag = o.getColumn('mag')
err = o.getColumn('err')
startDate = numpy.min(MJD)
endDate = numpy.max(MJD)
magMax = numpy.max(mag) + err[numpy.argmax(mag)]
magMin = numpy.min(mag) - err[numpy.argmin(mag)]
meanError = numpy.mean(err)
print "%s Start date: %f, End date: %f"%(o.id, startDate, endDate)
ppgplot.pgenv(startDate, endDate, magMax + meanError*2, magMin - meanError*2, 0, 0)
ppgplot.pgpt(MJD, mag)
ppgplot.pgerrb(2, MJD, mag, err, 0)
ppgplot.pgerrb(4, MJD, mag, err, 0)
ppgplot.pglab("MJD", "CRTS mag", "%s [%d]"%(o.id, len(MJD)))
ppgplot.pgclos()
# Compute HJDs for the observations
for o in objects:
hasEphemeris = o.loadEphemeris()
if hasEphemeris: o.computeHJDs()
##########################################################################################################################
# Periodograms
##########################################################################################################################
def gotoit():
nbin = 10
#c=Cluster()
#g=Galaxy()
clusterfile = "clusters.spec.dat"
print "reading in cluster file to get cluster parameters"
c.creadfiles(clusterfile)
print "got ", len(c.z), " clusters"
c.convarray()
c.Kcorr()
go2 = [] #combined arrays containing all galaxies
gsf = [] #combined arrays containing all galaxies
gsig5 = []
gsig10 = []
gsig52r200 = [] #spec catalogs extended out to 2xR200
gsig102r200 = [] #spec catalogs extended out to 2xR200
gsig5phot = []
gsig10phot = []
sgo2 = [] #combined arrays containing all galaxies
sgha = [] #combined arrays containing all galaxies
sgsf = [] #combined arrays containing all galaxies
sgsig5 = []
sgsig10 = []
sgsig52r200 = [] #spec catalogs extended out to 2xR200
sgsig102r200 = [] #spec catalogs extended out to 2xR200
sgsig5phot = []
sgsig10phot = []
if (mode < 1):
c.getsdssphotcats()
c.getsdssspeccats()
gr = [] #list of median g-r colors
psplotinit('summary.ps')
x1 = .1
x2 = .45
x3 = .6
x4 = .95
y1 = .15
y2 = .45
y3 = .55
y4 = .85
ppgplot.pgsch(1.2) #font size
ppgplot.pgslw(2)
#for i in range(len(c.z)):
cl = [10]
(xl, xu, yl, yu) = ppgplot.pgqvp(0)
print "viewport = ", xl, xu, yl, yu
complall = []
for i in range(len(c.z)):
#for i in cl:
gname = "g" + str(i)
gname = Galaxy()
gspecfile = "abell" + str(c.id[i]) + ".spec.dat"
gname.greadfiles(gspecfile, i)
print "number of members = ", len(gname.z)
if len(gname.z) < 10:
print "less than 10 members", len(gname.z)
continue
gname.convarray()
#gname.cullmembers()
#gname.getmemb()#get members w/in R200
#gr.append(N.average(gname.g-gname.r))
gspec2r200file = "abell" + str(c.id[i]) + ".spec2r200.dat"
gname.greadspecfiles(gspec2r200file, c.dL[i], c.kcorr[i], i)
print i, c.id[i], " getnearest, first call", len(gname.ra), len(
gname.sra), sum(gname.smemb)
#gname.getnearest(i)
(gname.sig52r200, gname.sig102r200) = gname.getnearestgen(
gname.ra, gname.dec, gname.sra, gname.sdec, i
) #measure distances from ra1, dec1 to members in catalog ra2, dec2
sig52r200 = N.compress(gname.memb > 0, gname.sig52r200)
gsig52r200[len(gsig5phot):] = sig52r200
sig102r200 = N.compress(gname.memb > 0, gname.sig102r200)
gsig102r200[len(gsig10phot):] = sig102r200
gphotfile = "abell" + str(c.id[i]) + ".phot.dat"
gname.greadphotfiles(gphotfile, c.dL[i], c.kcorr[i])
gname.getnearest(i)
#print "len of local density arrays = ",len(gname.sig5),len(gname.sig5phot)
#print gspecfile, c.z[i],c.kcorr[i]
(ds5, ds10) = gname.gwritefiles(gspecfile, i)
o2 = N.compress(gname.memb > 0, gname.o2)
go2[len(go2):] = o2
sf = N.compress(gname.memb > 0, gname.sf)
gsf[len(gsf):] = sf
sig5 = N.compress(gname.memb > 0, gname.sig5)
gsig5[len(gsig5):] = sig5
sig10 = N.compress(gname.memb > 0, gname.sig10)
gsig10[len(gsig10):] = sig10
sig5phot = N.compress(gname.memb > 0, gname.sig5phot)
gsig5phot[len(gsig5phot):] = sig5phot
sig10phot = N.compress(gname.memb > 0, gname.sig10phot)
gsig10phot[len(gsig10phot):] = sig10phot
ds5 = N.array(ds5, 'f')
ds10 = N.array(ds10, 'f')
#print len(ds5),len(ds10)
#ppgplot.pgsvp(xl,xu,yl,yu)
ppgplot.pgsvp(0.1, .9, .08, .92)
ppgplot.pgslw(7)
label = 'Abell ' + str(
c.id[i]) + ' (z=%5.2f, \gs=%3.0f km/s)' % (c.z[i], c.sigma[i])
ppgplot.pgtext(0., 1., label)
ppgplot.pgslw(2)
ppgplot.pgsvp(x1, x2, y1, y2) #sets viewport
#ppgplot.pgbox("",0.0,0,"",0.0)
ppgplot.pgswin(-1., 3., -1., 3.) #axes limits
ppgplot.pgbox('bcnst', 1, 2, 'bcvnst', 1, 2) #tickmarks and labeling
ppgplot.pgmtxt('b', 2.5, 0.5, 0.5,
"\gS\d10\u(phot) (gal/Mpc\u2\d)") #xlabel
ppgplot.pgmtxt('l', 2.6, 0.5, 0.5, "\gS\d10\u(spec) (gal/Mpc\u2\d)")
x = N.arange(-5., 10., .1)
y = x
ppgplot.pgsls(1) #dotted
ppgplot.pgslw(4) #line width
ppgplot.pgline(x, y)
x = N.log10(sig10phot)
y = N.log10(sig10)
ppgplot.pgsch(.7)
ppgplot.pgpt(x, y, 17)
xp = N.array([-0.5], 'f')
yp = N.array([2.5], 'f')
ppgplot.pgpt(xp, yp, 17)
ppgplot.pgtext((xp + .1), yp, 'spec(1.2xR200) vs phot')
ppgplot.pgsci(4)
xp = N.array([-0.5], 'f')
yp = N.array([2.2], 'f')
ppgplot.pgpt(xp, yp, 21)
ppgplot.pgtext((xp + .1), yp, 'spec(2xR200) vs phot')
y = N.log10(sig102r200)
ppgplot.pgsch(.9)
ppgplot.pgpt(x, y, 21)
ppgplot.pgsch(1.2)
ppgplot.pgslw(2) #line width
ppgplot.pgsci(1)
#ppgplot.pgenv(-200.,200.,-1.,20.,0,0)
#ppgplot.pgsci(2)
#ppgplot.pghist(len(ds5),ds5,-200.,200.,30,1)
#ppgplot.pgsci(4)
#ppgplot.pghist(len(ds10),ds10,-200.,200.,30,1)
#ppgplot.pgsci(1)
#ppgplot.pglab("\gD\gS","Ngal",gspecfile)
#ppgplot.pgpanl(1,2)
g = N.compress(gname.memb > 0, gname.g)
r = N.compress(gname.memb > 0, gname.r)
V = N.compress(gname.memb > 0, gname.V)
dmag = N.compress(gname.memb > 0, gname.dmagnearest)
dnearest = N.compress(gname.memb > 0, gname.nearest)
dz = N.compress(gname.memb > 0, gname.dz)
#ppgplot.pgsvp(x3,x4,y1,y2) #sets viewport
#ppgplot.pgenv(-.5,3.,-1.,5.,0,0)
#ppgplot.pgpt((g-V),(g-r),17)
#ppgplot.pgsci(1)
#ppgplot.pglab("g - M\dV\u",'g-r',gspecfile)
ppgplot.pgsvp(x1, x2, y3, y4) #sets viewport
#ppgplot.pgbox("",0.0,0,"",0.0)
ppgplot.pgswin(
(c.ra[i] + 2. * c.r200deg[i] / N.cos(c.dec[i] * N.pi / 180.)),
(c.ra[i] - 2 * c.r200deg[i] / N.cos(c.dec[i] * N.pi / 180.)),
(c.dec[i] - 2. * c.r200deg[i]), (c.dec[i] + 2. * c.r200deg[i]))
ppgplot.pgbox('bcnst', 0.0, 0.0, 'bcvnst', 0.0,
0.0) #tickmarks and labeling
ppgplot.pgmtxt('b', 2.5, 0.5, 0.5, "RA") #xlabel
ppgplot.pgmtxt('l', 2.6, 0.5, 0.5, "Dec")
#ppgplot.pglab("RA",'Dec',gspecfile)
ppgplot.pgsfs(2)
ppgplot.pgcirc(c.ra[i], c.dec[i], c.r200deg[i])
ppgplot.pgsls(4)
ppgplot.pgcirc(c.ra[i], c.dec[i], 1.2 * c.r200deg[i])
ppgplot.pgsls(1)
#ppgplot.pgcirc(c.ra[i],c.dec[i],c.r200deg[i]/N.cos(c.dec[i]*N.pi/180.))
ppgplot.pgsci(2)
ppgplot.pgpt(gname.ra, gname.dec, 17)
ppgplot.pgsci(4)
ppgplot.pgpt(gname.photra, gname.photdec, 21)
ppgplot.pgsci(1)
#calculate completeness w/in R200
dspec = N.sqrt((gname.ra - c.ra[i])**2 + (gname.dec - c.dec[i])**2)
dphot = N.sqrt((gname.photra - c.ra[i])**2 +
(gname.photdec - c.dec[i])**2)
nphot = 1. * len(N.compress(dphot < c.r200deg[i], dphot))
nspec = 1. * len(N.compress(dspec < c.r200deg[i], dspec))
s = "Completeness for cluster Abell %s = %6.2f (nspec=%6.1f,nphot= %6.1f)" % (
str(c.id[i]), float(nspec / nphot), nspec, nphot)
print s
complall.append(float(nspec / nphot))
ppgplot.pgsvp(x3, x4, y3, y4) #sets viewport
#ppgplot.pgsvp(x1,x2,y3,y4) #sets viewport
#ppgplot.pgbox("",0.0,0,"",0.0)
ppgplot.pgswin(-0.005, .05, -1., 1.)
ppgplot.pgbox('bcnst', .02, 2, 'bcvnst', 1, 4) #tickmarks and labeling
ppgplot.pgsch(1.0)
ppgplot.pgmtxt('b', 2.5, 0.5, 0.5,
"Dist to nearest phot neighbor (deg)") #xlabel
ppgplot.pgsch(1.2)
ppgplot.pgmtxt('l', 2.6, 0.5, 0.5, 'M\dV\u(phot) - M\dV\u(spec)')
ppgplot.pgsci(2)
ppgplot.pgpt(dnearest, dmag, 17)
ppgplot.pgsci(1)
x = N.arange(-30., 30., 1.)
y = 0 * x
ppgplot.pgsci(1)
ppgplot.pgsls(2)
ppgplot.pgline(x, y)
ppgplot.pgsls(1)
ppgplot.pgsci(1)
dm = N.compress(dnearest < 0.01, dmag)
std = '%5.3f (%5.3f)' % (pylab.mean(dm), pylab.std(dm))
#ppgplot.pgslw(7)
#label='Abell '+str(c.id[i])
#ppgplot.pgtext(0.,1.,label)
ppgplot.pgslw(2)
label = '\gDM\dV\u(err) = ' + std
ppgplot.pgsch(.9)
ppgplot.pgtext(0., .8, label)
#label = "z = %5.2f"%(c.z[i])
#ppgplot.pgtext(0.,.8,label)
ppgplot.pgsch(1.2)
#ppgplot.pgsvp(x3,x4,y3,y4) #sets viewport
#ppgplot.pgenv(-.15,.15,-3.,3.,0,0)
#ppgplot.pgsci(2)
#ppgplot.pgpt(dz,dmag,17)
#ppgplot.pgsci(1)
#ppgplot.pglab("z-z\dcl\u",'\gD Mag',gspecfile)
ppgplot.pgsvp(x3, x4, y1, y2) #sets viewport
ppgplot.pgswin(-3., 3., -1., 1.)
ppgplot.pgbox('bcnst', 1, 2, 'bcvnst', 1, 4) #tickmarks and labeling
ppgplot.pgmtxt('b', 2.5, 0.5, 0.5, "\gDv/\gs") #xlabel
ppgplot.pgmtxt('l', 2.6, 0.5, 0.5, 'M\dV\u(phot) - M\dV\u(spec)')
ppgplot.pgsci(2)
dv = dz / (1 + c.z[i]) * 3.e5 / c.sigma[i]
ppgplot.pgpt(dv, dmag, 17)
ppgplot.pgsci(1)
x = N.arange(-30., 30., 1.)
y = 0 * x
ppgplot.pgsci(1)
ppgplot.pgsls(2)
ppgplot.pgline(x, y)
ppgplot.pgsls(1)
ppgplot.pgsci(1)
#ppgplot.pgsvp(x1,x2,y1,y2) #sets viewport
#ppgplot.pgenv(0.,3.5,-3.,3.,0,0)
#ppgplot.pgsci(4)
#ppgplot.pgpt((g-r),dmag,17)
#ppgplot.pgsci(1)
#ppgplot.pglab("g-r",'\gD Mag',gspecfile)
#ppgplot.pgsvp(x1,x2,y1,y2) #sets viewport
#ppgplot.pgenv(-25.,-18.,-1.,1.,0,0)
#ppgplot.pgsci(4)
#ppgplot.pgpt((V),dmag,17)
#x=N.arange(-30.,30.,1.)
#y=0*x
#ppgplot.pgsci(1)
#ppgplot.pgsls(2)
#ppgplot.pgline(x,y)
#ppgplot.pgsls(1)
#ppgplot.pgsci(1)
#ppgplot.pglab("M\dV\u(spec)",'M\dV\u(phot) - M\dV\u(spec)',gspecfile)
#ppgplot.pgpage()
#ppgplot.pgpage()
#combine galaxy data
ppgplot.pgpage()
(sssig5,
sssig10) = gname.getnearestgen(gname.sra, gname.sdec, gname.sra,
gname.sdec,
i) #get spec-spec local density
(spsig5,
spsig10) = gname.getnearestgen(gname.sra, gname.sdec, gname.photra,
gname.photdec,
i) #get spec-phot local density
o2 = N.compress(gname.smemb > 0, gname.so2)
sgo2[len(sgo2):] = o2
ha = N.compress(gname.smemb > 0, gname.sha)
sgha[len(sgha):] = ha
sf = N.compress(gname.smemb > 0, gname.ssf)
sgsf[len(sgsf):] = sf
sig5 = N.compress(gname.smemb > 0, sssig5)
sgsig5[len(sgsig5):] = sig5
sig10 = N.compress(gname.smemb > 0, sssig10)
sgsig10[len(sgsig10):] = sig10
sig5phot = N.compress(gname.smemb > 0, spsig5)
sgsig5phot[len(sgsig5phot):] = sig5phot
sig10phot = N.compress(gname.smemb > 0, spsig10)
sgsig10phot[len(sgsig10phot):] = sig10phot
#gr=N.array(gr,'f')
#c.assigncolor(gr)
#for i in range(len(c.z)):
# print c.id[i],c.z[i],c.r200[i],c.r200deg[i]
print "Average Completeness w/in R200 = ", N.average(N.array(
complall, 'f'))
print "sig o2", len(gsig10), len(gsig10phot), len(go2)
print "sig o2 large", len(sgsig10), len(sgsig10phot), len(sgo2)
plotsigo2all(gsig10, gsig10phot, go2, 'o2vsig10spec', nbin)
#plotsigo2(gsig5phot,-1*go2,'o2vsig5phot',nbin)
plotsigsff(gsig5, gsf, 'sffvsig5spec', nbin) #sf frac versus sigma
plotsigsff(gsig5phot, gsf, 'sffvsig5phot', nbin) #sf frac versus sigma
plotsigsffall(gsig5, gsig5phot, gsf, 'sffvsig5all',
nbin) #sf frac versus sigma
plotsig10sffall(gsig10, gsig10phot, gsf, 'sffvsig10all',
nbin) #sf frac versus sigma
#plotsighaall(gsig10,gsig10phot,gha,'havsig10spec',20)
#plotsigo2all(sgsig10,sgsig10phot,sgo2,'o2vsig10spec.large',30)
plotsighaall(sgsig10, sgsig10phot, sgha, 'havsig10spec.large', 10)
#plotsigsffall(sgsig5,sgsig5phot,sgsf,'sffvsig5.large',nbin)#sf frac versus sigma
#plotsig10sffall(sgsig10,sgsig10phot,sgsf,'sffvsig10.large',nbin)#sf frac versus sigma
psplotinit('one2one.ps')
ppgplot.pgenv(-1.5, 2.5, -1.5, 2.5, 0)
ppgplot.pglab("\gS\d10\u(phot) (gal/Mpc\u2\d)",
"\gS\d10\u(spec) (gal/Mpc\u2\d)", "")
x = N.arange(-5., 10., .1)
y = x
ppgplot.pgsls(1) #dotted
ppgplot.pgslw(4) #line width
ppgplot.pgline(x, y)
x = N.log10(gsig10phot)
y = N.log10(gsig10)
ppgplot.pgsch(.7)
ppgplot.pgpt(x, y, 17)
ppgplot.pgsch(1.)
ppgplot.pgsci(1)
ppgplot.pgend()
spectrum = spectrumClasses.spectrumObject()
spectrum.loadFromJSON(f)
print "Loaded %s, contains %s."%(f, spectrum.objectName)
spectra.append(spectrum)
mainPGPlotWindow = ppgplot.pgopen(device)
ppgplot.pgask(True)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
for spectrum in spectra:
ppgplot.pgsci(1)
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
lowerFlux = min(spectrum.flux)
upperFlux = max(spectrum.flux)
ppgplot.pgenv(lowerWavelength, upperWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgline(spectrum.wavelengths, spectrum.flux)
ppgplot.pgsci(1)
if hasEphemeris:
ppgplot.pglab("wavelength", "flux", "%s [%f]"%(spectrum.objectName, ephemeris.getPhase(spectrum.HJD)))
else:
ppgplot.pglab("wavelength", "flux", spectrum.objectName)
if ncl == 5:
title = "MS1054"
#a=.008
#b=.165*a
n = 1.45
if ncl == 6:
title = "HDFN1"
#a=.008
#b=.165*a
n = 1.45
ymin = -.05
ymax = max(aveaperr)
#ymax=10.
ppgplot.pgenv(DATAMIN, DATAMAX, ymin, ymax, 0)
ppgplot.pglab("linear size N of aperture (pixel)", "rms in Sky (ADU/s)", title)
ppgplot.pgsci(2) #red
ppgplot.pgslw(4) #line width
x = N.sqrt(avearea)
y = aveaperr
ppgplot.pgpt(x, y, 7)
#errory(x,y,erry)
ppgplot.pgsci(1) #black
#ppgplot.pgpt(isoarea,fluxerriso,3)
#x1=N.sqrt(contsubisoarea)
#y1=contsuberr
x1 = N.sqrt(isoarea)
y1 = fluxerriso
y = n * y1
ppgplot.pgpt(x1, y1, 1)
def plothistsfr():
DATAMIN = -4.
DATAMAX = 15.
NBIN = int((DATAMAX-DATAMIN)*2.)
#print "ngal = ",len(g0.sfr)
ppgplot.pgbox("",0.0,0,"L",0.0,0)
ppgplot.pgenv(DATAMIN,DATAMAX,0,45,0)
ppgplot.pglab("SFR (h\d100\u\u-2\d M\d\(2281)\u yr\u-1 \d)","Number of Galaxies","")
ppgplot.pgsls(1)#dotted
ppgplot.pgslw(4) #line width
#ppgplot.pgsci(4)
#x=N.compress((abs(g0.ew) > ewmin),g0.sfr)
x=N.compress((g0.final > 0),g0.sfrc)
ppgplot.pghist(len(x),x,DATAMIN,DATAMAX,NBIN,5)
xlabel = 6.5
ylabel = 38.
ystep = 3.
dy=.4
dxl=3
dxr=.5
ppgplot.pgslw(deflw) #line width
ppgplot.pgtext(xlabel,ylabel,"CL1040")
xlin = N.array([xlabel-dxl,xlabel-dxr],'f')
ylin = N.array([ylabel+dy,ylabel+dy],'f')
ppgplot.pgslw(4) #line width
ppgplot.pgline(xlin,ylin)
ppgplot.pgslw(5)
ppgplot.pgsls(3)#dot-dash-dot-dash
#ppgplot.pgsci(3)
#x=N.compress((abs(g1.ew) > ewmin),g1.sfr)
x=N.compress((g1.final > 0),g1.sfrc)
ppgplot.pghist(len(x),x,DATAMIN,DATAMAX,NBIN,5)
ylabel = ylabel - ystep
xlin = N.array([xlabel-dxl,xlabel-dxr],'f')
ylin = N.array([ylabel+dy,ylabel+dy],'f')
ppgplot.pgline(xlin,ylin)
ppgplot.pgsls(1)
ppgplot.pgslw(deflw)
ppgplot.pgtext(xlabel,ylabel,"CL1054-12")
ppgplot.pgsls(1)#dot-dash-dot-dash
#ppgplot.pgsci(2)
ppgplot.pgslw(2) #line width
#x=N.compress((abs(g2.ew) > ewmin),g2.sfr)
x=N.compress((g2.final > 0),g2.sfrc)
ppgplot.pghist(len(x),x,DATAMIN,DATAMAX,NBIN,5)
ylabel = ylabel - ystep
ppgplot.pgslw(deflw) #line width
ppgplot.pgtext(xlabel,ylabel,"CL1216")
xlin = N.array([xlabel-dxl,xlabel-dxr],'f')
ylin = N.array([ylabel+dy,ylabel+dy],'f')
ppgplot.pgslw(2) #line width
ppgplot.pgline(xlin,ylin)
#print "Number in g2.ratios = ",len(g2.ratio)
#for ratio in g2.ratio:
# print ratio
#drawbinned(x,y,5)
ppgplot.pgsci(1)
""" Set up the PGPLOT windows """
xyPositionPlot = {}
xyPositionPlot['pgplotHandle'] = ppgplot.pgopen('/xs')
xyPositionPlot['yLimit'] = 1.0
xyPositionPlot['numXYPanels'] = len(referenceApertures.sources)
ppgplot.pgpap(6.18, 1.618)
ppgplot.pgsubp(1, xyPositionPlot['numXYPanels'])
ppgplot.pgsci(5)
for panel in range(xyPositionPlot['numXYPanels']):
currentSize = ppgplot.pgqch()
ppgplot.pgsch(1)
yLimit = xyPositionPlot['yLimit']
ppgplot.pgenv(startFrame, startFrame + frameRange, -yLimit, yLimit, 0, -2)
ppgplot.pgbox('A', 0.0, 0, 'BCG', 0.0, 0)
ppgplot.pglab("", "%d"%panel, "")
ppgplot.pgsch(currentSize)
ppgplot.pgask(False)
ppgplot.pgsci(1)
if (arg.preview):
bitmapView = {}
bitmapView['pgplotHandle'] = ppgplot.pgopen('/xs')
ppgplot.pgpap(8, 1)
ppgplot.pgenv(0.,fullFramexsize,0.,fullFrameysize, 1, 0)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgsfs(2)
angleArray = []
# Plot theta as a function of orbital phase for these parameters
for phase in numpy.arange(0.5, 1.51, 0.01):
theta = computeViewingAngle(phase, inclination, beta, phi)
phaseArray.append(phase)
angleArray.append(theta)
mainPlotWindow = ppgplot.pgopen("/xs")
ppgplot.pgask(False)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgsci(1)
ppgplot.pgenv(min(phaseArray), max(phaseArray), 0, 180, 0, 0)
ppgplot.pgline(phaseArray, angleArray)
ppgplot.pgsls(2)
ppgplot.pgline([0.5, 1.5], [90, 90])
ppgplot.pglab("orbital phase", "viewing angle", "Viewing angle \gh as a function of orbital phase.")
ppgplot.pgtext(0.6, 150, "i:%2.0f \gb:%2.0f \gf:%2.0f"%(inclination, beta, phi))
modelPlotWindow = ppgplot.pgopen("models_i_81_b_40.ps/ps")
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgask(False)
mainFluxMax = 0
mainFluxMin = 1E99
for phase in numpy.arange(0.5, 1.6, 0.1):
ppgplot.pgsci(1)
theta = computeViewingAngle(phase, inclination, beta, phi)
intensities = ["i", "i_0", "i_1"]
lineStyles = [1, 2, 3]
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_rating_sheet(rating):
"""
Plot a fact sheet on the ratings in the database corresponding to 'rating'.
'rating' is a dictionary of information from the MySQL database (as returned
by 'get_all_rating_types()'.
"""
plot_utils.beginplot("rating_report%s.ps" % currdatetime.strftime('%y%m%d'), vertical=True)
ch0 = ppgplot.pgqch()
ppgplot.pgsch(0.5)
ch = ppgplot.pgqch()
ppgplot.pgsch(0.75)
ppgplot.pgtext(0,1,"Rating Report for %s (%s) - page 1 of 2" % (rating["name"], currdatetime.strftime('%c')))
ppgplot.pgsch(ch)
# Plot Histograms
all_ratings = get_ratings(rating["rating_id"])
range = xmin,xmax = np.min(all_ratings), np.max(all_ratings)
ppgplot.pgsci(1)
ppgplot.pgslw(1)
#===== Total/Classified/Unclassified
# Get data
ppgplot.pgsvp(0.1, 0.9, 0.75, 0.9)
(tot_counts, tot_left_edges)=np.histogram(all_ratings, bins=NUMBINS, range=range)
ppgplot.pgswin(xmin,xmax,0,np.max(tot_counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCTS",0,5,"BCNTS",0,5)
ppgplot.pgbin(tot_left_edges, tot_counts)
(clsfd_counts, clsfd_left_edges)=np.histogram(get_ratings(rating["rating_id"], human_classification=(1,2,3,4,5,6,7)), bins=NUMBINS, range=range)
ppgplot.pgsci(3) # plot classified in green
ppgplot.pgbin(tot_left_edges, clsfd_counts)
unclsfd_counts = tot_counts-clsfd_counts
ppgplot.pgsci(2) # plot unclassified in red
ppgplot.pgbin(tot_left_edges, unclsfd_counts)
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab("","Counts","")
#===== Class 1/2/3
ppgplot.pgsvp(0.1, 0.9, 0.6, 0.75)
(counts, left_edges)=np.histogram(get_ratings(rating["rating_id"], human_classification=(1,2,3)), bins=NUMBINS, range=range)
ppgplot.pgswin(xmin,xmax,0,np.max(counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCTS",0,5,"BCNTS",0,5)
ppgplot.pgsci(1) # plot in black
ppgplot.pgbin(tot_left_edges, counts)
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab("","Class 1/2/3","")
#===== RFI
ppgplot.pgsvp(0.1, 0.9, 0.45, 0.6)
rfi_ratings = get_ratings(rating["rating_id"], human_classification=(4,))
(counts, left_edges)=np.histogram(rfi_ratings, bins=NUMBINS, range=range)
ppgplot.pgswin(xmin,xmax,0,np.max(counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCTS",0,5,"BCNTS",0,5)
ppgplot.pgsci(1) # plot in black
ppgplot.pgbin(tot_left_edges, counts)
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab("","RFI","")
#===== Noise
ppgplot.pgsvp(0.1, 0.9, 0.3, 0.45)
noise_ratings = get_ratings(rating["rating_id"], human_classification=(5,))
(counts, left_edges)=np.histogram(noise_ratings, bins=NUMBINS, range=range)
ppgplot.pgswin(xmin,xmax,0,np.max(counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCTS",0,5,"BCNTS",0,5)
ppgplot.pgsci(1) # plot in black
ppgplot.pgbin(tot_left_edges, counts)
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab("","Noise","")
#===== Known/Harmonic
ppgplot.pgsvp(0.1, 0.9, 0.15, 0.3)
known_ratings = get_ratings(rating["rating_id"], human_classification=(6,7))
(counts, left_edges)=np.histogram(known_ratings, bins=NUMBINS, range=range)
ppgplot.pgswin(xmin,xmax,0,np.max(counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCNTS",0,5,"BCNTS",0,5)
ppgplot.pgsci(1) # plot in black
ppgplot.pgbin(tot_left_edges, counts)
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab(rating["name"],"Known/Harmonic","")
#===== Second page for differential histograms
plot_utils.nextpage(vertical=True)
ppgplot.pgsch(0.75)
ppgplot.pgtext(0,1,"Rating Report for %s (%s) - page 2 of 2" % (rating["name"], currdatetime.strftime('%c')))
#===== RFI - Known
ppgplot.pgsvp(0.1, 0.9, 0.75, 0.9)
if rfi_ratings.size==0 or known_ratings.size==0:
ppgplot.pgswin(0,1,0,1)
ppgplot.pgbox("BC",0,0,"BC",0,0)
ppgplot.pgsch(0.75)
ppgplot.pglab("","RFI - Known","")
ppgplot.pgsch(1.0)
ppgplot.pgptxt(0.5, 0.5, 0.0, 0.5, "Not enough data")
else:
(known_counts, known_left_edges)=np.histogram(known_ratings, bins=NUMBINS, range=range, normed=True)
(rfi_counts, rfi_left_edges)=np.histogram(rfi_ratings, bins=NUMBINS, range=range, normed=True)
diff_counts = rfi_counts - known_counts
ppgplot.pgswin(xmin,xmax,np.min(diff_counts)*1.1,np.max(diff_counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCTS",0,5,"BCNTS",0,5)
ppgplot.pgbin(tot_left_edges, diff_counts)
ppgplot.pgsci(2) # set colour to red
ppgplot.pgline(tot_left_edges, np.zeros_like(tot_left_edges))
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab("","RFI - Known","")
#===== RFI - Noise
ppgplot.pgsvp(0.1, 0.9, 0.6, 0.75)
if noise_ratings.size==0 or rfi_ratings.size==0:
ppgplot.pgswin(0,1,0,1)
ppgplot.pgbox("BC",0,0,"BC",0,0)
ppgplot.pgsch(0.75)
ppgplot.pglab("","RFI - Noise","")
ppgplot.pgsch(1.0)
ppgplot.pgptxt(0.5, 0.5, 0.0, 0.5, "Not enough data")
else:
(noise_counts, noise_left_edges)=np.histogram(noise_ratings, bins=NUMBINS, range=range, normed=True)
(rfi_counts, rfi_left_edges)=np.histogram(rfi_ratings, bins=NUMBINS, range=range, normed=True)
diff_counts = rfi_counts - noise_counts
ppgplot.pgswin(xmin,xmax,np.min(diff_counts)*1.1,np.max(diff_counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCTS",0,5,"BCNTS",0,5)
ppgplot.pgbin(tot_left_edges, diff_counts)
ppgplot.pgsci(2) # set colour to red
ppgplot.pgline(tot_left_edges, np.zeros_like(tot_left_edges))
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgsch(0.75)
ppgplot.pglab("","RFI - Noise","")
#===== Known - Noise
ppgplot.pgsvp(0.1, 0.9, 0.45, 0.6)
if noise_ratings.size==0 or known_ratings.size==0:
ppgplot.pgswin(0,1,0,1)
ppgplot.pgbox("BC",0,0,"BC",0,0)
# Y-axis label is taken care of outside of if/else (below)
ppgplot.pgsch(1.0)
ppgplot.pgptxt(0.5, 0.5, 0.0, 0.5, "Not enough data")
else:
(noise_counts, noise_left_edges)=np.histogram(noise_ratings, bins=NUMBINS, range=range, normed=True)
(known_counts, known_left_edges)=np.histogram(known_ratings, bins=NUMBINS, range=range, normed=True)
diff_counts = known_counts - noise_counts
ppgplot.pgswin(xmin,xmax,np.min(diff_counts)*1.1,np.max(diff_counts)*1.1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("BCNTS",0,5,"BCNTS",0,5)
ppgplot.pgbin(tot_left_edges, diff_counts)
ppgplot.pgsci(2) # set colour to red
ppgplot.pgline(tot_left_edges, np.zeros_like(tot_left_edges))
ppgplot.pgsci(1) # reset colour to black
ppgplot.pgswin(xmin,xmax,0,1)
ppgplot.pgsch(0.5)
ppgplot.pgbox("NTS",0,5,"",0,0)
ppgplot.pgsch(0.75)
ppgplot.pglab(rating["name"],"Known - Noise","")
ppgplot.pgsch(ch0) # reset character height
#/usr/bin/env python
#
# pgex1: freely taken after PGDEMO1.F
#
import ppgplot, Numeric
import sys
# create an array
xs=Numeric.array([1.,2.,3.,4.,5.])
ys=Numeric.array([1.,4.,9.,16.,25.])
# creat another array
yr = 0.1*Numeric.array(range(0,60))
xr = yr*yr
# pgplotting
if len(sys.argv) > 1: # if we got an argument use the argument as devicename
ppgplot.pgopen(sys.argv[1])
else:
ppgplot.pgopen('?')
ppgplot.pgenv(0.,10.,0.,20.,0,1)
ppgplot.pglab('(x)', '(y)', 'PGPLOT Example 1: y = x\u2')
ppgplot.pgpt(xs,ys,9)
ppgplot.pgline(xr,yr)
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)
xScale = (max(spectrum.wavelengths) - min(spectrum.wavelengths)) / xSize
if hasEphemeris:
yScale = numPhaseBins
else:
yScale = len(spectra)
pgPlotTransform = [min(spectrum.wavelengths), xScale, 0, 0, 0, 1/float(yScale)]
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
ppgplot.pgenv( min(spectrum.wavelengths), max(spectrum.wavelengths), 0, 2, 0, 0)
ppgplot.pggray(generalUtils.percentiles(trailBitmap, 20, 99), 0, xSize-1 , 0, ySize-1 , 255, 0, pgPlotTransform)
# ppgplot.pggray(trailBitmap, 0, xSize-1 , 0, ySize-1 , numpy.max(trailBitmap), numpy.min(trailBitmap), pgPlotTransform)
epochs = [s.HJD for s in spectra]
startHJD = min(epochs)
endHJD = max(epochs)
if arg.title is None:
title = ""
else:
title = arg.title
if hasEphemeris:
# ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "Phase", "%s - %s"%(str(startHJD), str(endHJD)))
ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "Phase", title)
else:
#ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "Spectrum number", "%s - %s"%(str(spectra[0].HJD), str(spectra[-1].HJD)))
ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "Spectrum number", title)
ppgplot.pgask(False)
for index, o in enumerate(objects):
MJD = o.getColumn('MJD')
mag = o.getColumn('mag')
err = o.getColumn('err')
startDate = numpy.min(MJD)
endDate = numpy.max(MJD)
magMax = numpy.max(mag) + err[numpy.argmax(mag)]
magMin = numpy.min(mag) - err[numpy.argmin(mag)]
meanError = numpy.mean(err)
print "%s Start date: %f, End date: %f"%(o.id, startDate, endDate)
ppgplot.pgenv(startDate, endDate, magMax + meanError*2, magMin - meanError*2, 0, 0)
ppgplot.pgpt(MJD, mag)
ppgplot.pgerrb(2, MJD, mag, err, 0)
ppgplot.pgerrb(4, MJD, mag, err, 0)
ppgplot.pglab("MJD", "CRTS mag", "%s [%d]"%(o.id, len(MJD)))
ppgplot.pgclos()
# Compute HJDs for the observations
for o in objects:
hasEphemeris = o.loadEphemeris()
if hasEphemeris: o.computeHJDs()
# Load the PTF data
for o in objects:
targetName = o.id
print "Loading PTF data for ", targetName
dataFilename = targetName + '_ptf.dat'
def main(args):
with open(os.path.join(os.path.dirname(__file__),
'precisiondata.cpickle')) as filedata:
exptimes, crosspoints, satpoints = pickle.load(filedata)
x_range = [9, 14]
interpcross = interp1d(exptimes, crosspoints, kind='linear')
interpsat = interp1d(exptimes, satpoints, kind='linear')
N = 5
colours = np.arange(2, 2 + N, 1)
exptimes = np.arange(1, N + 1) * 10
if args.besancon:
all_vmags = get_besancon_mag_data()
yhigh = 0.3
title = 'Besancon'
else:
all_vmags = get_nomad_mag_data()
yhigh = 0.4
title = 'NOMAD'
ytot = yhigh * len(all_vmags)
with pgh.open_plot(args.output):
pg.pgvstd()
pg.pgswin(x_range[0], x_range[1], 0, yhigh)
for exptime, colour in zip(exptimes, colours):
satpoint = interpsat(exptime)
crosspoint = interpcross(exptime)
selected = all_vmags[(all_vmags > satpoint) & (all_vmags <=
crosspoint)]
print(exptime, len(selected))
xdata, ydata = cumulative_hist(np.array(selected),
min_val=x_range[0], max_val=x_range[1], norm=len(all_vmags))
ydata /= float(len(all_vmags))
with pgh.change_colour(colour):
pg.pgbin(xdata, ydata, False)
pg.pgbox('bcnst', 0, 0, 'bcnst', 0, 0)
pg.pglab(r'V magnitude', 'High precision fraction', title)
# Label the right hand side
pg.pgswin(x_range[0], x_range[1], 0, ytot)
pg.pgbox('', 0, 0, 'smt', 0, 0)
pg.pgmtxt('r', 2., 0.5, 0.5, 'N')
# Create the legend
pg.pgsvp(0.7, 0.9, 0.1, 0.3)
pg.pgswin(0., 1., 0., 1.)
for i, (exptime, colour) in enumerate(zip(exptimes, colours)):
yval = 0.1 + 0.8 * i / len(exptimes)
with pgh.change_colour(colour):
pg.pgline(np.array([0.2, 0.4]), np.ones(2) * yval)
pg.pgtext(0.5, yval, r'{:d} s'.format(exptime))
yLower = -0.5
fitPGPlotWindow = ppgplot.pgopen(arg.device)
ppgplot.pgask(False)
for spectrum in spectra:
ppgplot.pgslct(mainPGPlotWindow)
ppgplot.pgsci(1)
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
lowerFlux = min(spectrum.flux)
upperFlux = max(spectrum.flux)
ppgplot.pgenv(lowerWavelength, upperWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgbin(spectrum.wavelengths, spectrum.flux)
ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "flux [%s]"%spectrum.fluxUnits, "%s [%s]"%(spectrum.objectName, spectrum.loadedFromFilename))
# Grab the continuum from either side of the spectrum
lowerCut = 6540
upperCut = 6585
continuumSpectrum = copy.deepcopy(spectrum)
continuumSpectrum.snipWavelengthRange(lowerCut, upperCut)
ppgplot.pgsci(2)
ppgplot.pgbin(continuumSpectrum.wavelengths, continuumSpectrum.flux)
# Now fit a polynomial to continuum around the doublet
a0 = 0.0 # Constant term
a0 = numpy.mean(continuumSpectrum.flux)
a1 = 0.0 # Linear term
a2 = 0.0 # Quadratic term
for index, o in enumerate(objects):
HJD = o.getColumn('HJD')
mag = o.getColumn('mag')
err = o.getColumn('err')
startDate = numpy.min(HJD)
dates = [ d - startDate for d in HJD]
endDate = numpy.max(HJD)
magMax = numpy.max(mag) + err[numpy.argmax(mag)]
magMin = numpy.min(mag) - err[numpy.argmin(mag)]
meanError = numpy.mean(err)
print "%s Start date: %f, End date: %f"%(o.id, startDate, endDate)
ppgplot.pgenv(0, numpy.max(dates), magMax + meanError*2, magMin - meanError*2, 0, 0)
ppgplot.pgpt(dates, mag)
ppgplot.pgerrb(2, dates, mag, err, 0)
ppgplot.pgerrb(4, dates, mag, err, 0)
ppgplot.pglab("Days since %f"%startDate, "PTF mag", "%s [%d]"%(o.id, len(HJD)))
ppgplot.pgclos()
# Load the ephemerides
for o in objects:
hasEphemeris = o.loadEphemeris()
print o.ephemeris
# Write the object data to a textfile
for o in objects:
o.computePhases()
o.sortData('phase')
o.writeData(o.id + "_phases.dat")
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()
y_values = photometry[yColumn] y_errors = photometry[yErrors] x_lower, x_upper = (min(x_values), max(x_values)) numpoints = len(x_values) if "JD" in xColumn: x_offset = int(x_lower) x_values = [(x-x_offset) for x in x_values] xLabel= xColumn + " - %d"%x_lower ppgplot.pgsci(1) ppgplot.pgenv(min(x_values), max(x_values), lowerY, upperY, 0, 0) ppgplot.pgslw(7) ppgplot.pgpt(x_values, y_values, 1) ppgplot.pgslw(1) ppgplot.pgerrb(2, x_values, y_values, y_errors, 0) ppgplot.pgerrb(4, x_values, y_values, y_errors, 0) ppgplot.pglab(xLabel, yLabel, photometry["runName"]) ppgplot.pgclos() if not hasEphemeris: sys.exit() # Restrict the light-curve to a subset of phase phaseLimits = (0.51, 0.70) for photometry in allData: pnew = [] ynew = [] yenew = [] for (p, y, ye) in zip(photometry["phase"], photometry[yColumn], photometry[yErrors]): if p>phaseLimits[0] and p<phaseLimits[1]: pnew.append(p)
targetName = spectrum.parseHeaderInfo(head)
print "Parsed headers of", targetName
print r.oneLine()
if fileIndex == 0:
spectra.append(spectrum)
else:
spectra[index].appendNewData(spectrum)
numSpectra = len(spectra)
print "%d spectra have been loaded."%numSpectra
mainPGPlotWindow = ppgplot.pgopen('/xs')
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgask(False)
ppgplot.pglab("wavelength", "flux", "spectrum")
phases = []
rvs = []
wvshifts = []
wvshiftErrors = []
previousWavelengthFit = 8173.0
for spectrum in spectra:
spectrum.trimWavelengthRange(8000, 8400)
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
lowerFlux = min(spectrum.flux)
upperFlux = max(spectrum.flux)
ppgplot.pgsci(1)
ppgplot.pgenv(lowerWavelength, upperWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgline(spectrum.wavelengths, spectrum.flux)
if hasEphemeris:
spectrum.snipWavelengthRange(6550, 6570)
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
observedSpectrumRange = (lowerWavelength, upperWavelength)
lowerFlux = min(spectrum.flux)
upperFlux = max(spectrum.flux)
lowerFlux = 0
mainPlotWindow = ppgplot.pgopen(arg.device)
ppgplot.pgask(False)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgsci(1)
ppgplot.pgenv(lowerWavelength, upperWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgline(spectrum.wavelengths, spectrum.flux)
ppgplot.pglab("wavelength", "flux", spectrum.objectName)
observedArea = spectrum.integrate()
print "Wavelength range of observations:", observedSpectrumRange
# modelPlotWindow = ppgplot.pgopen(arg.device)
# pgPlotTransform = [0, 1, 0, 0, 0, 1]
# ppgplot.pgask(False)
currentPlotWindow = ppgplot.pgopen(arg.device)
ppgplot.pgask(False)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgslct(currentPlotWindow)
ppgplot.pgenv(lowerWavelength, upperWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgline(spectrum.wavelengths, spectrum.flux)
ppgplot.pglab("wavelength", "flux", "Current fit")
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))
o.calculateOffsets()
o.calculateFluxes()
o.addWavelengths(wavelengthLookup)
PGPlotWindow = ppgplot.pgopen(arg.device)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgslct(PGPlotWindow)
ppgplot.pgsci(1)
ppgplot.pgask(True)
for o in objects:
ppgplot.pgsch(1.6)
wavelengths, fluxes, fluxerrors, bands = o.getFluxData()
fluxMax = max(fluxes)
fluxMin = min(fluxes)
wavelengthMin = min(wavelengths)
wavelengthMax = max(wavelengths)
ppgplot.pgenv(500,25000 , 0, fluxMax*1.2, 0)
ppgplot.pglab("wavelength [\A]", "f\d\gn\u [mJy]", o.objectID)
ppgplot.pgsch(1.0)
ppgplot.pgpt(wavelengths, fluxes)
ppgplot.pgerrb(2, wavelengths, fluxes, fluxerrors, 0)
ppgplot.pgerrb(4, wavelengths, fluxes, fluxerrors, 0)
ppgplot.pgclos()
sys.exit()
for x in range(numPoints):
times.append(seconds)
brightness.append(sinecurve(seconds, period))
seconds+= step
lightCurve = lightCurve()
lightCurve.initValues(times, brightness)
lightCurve.period = period * 60.
lightCurve.brightness[3] = 1.0
lightCurvePlot = {}
lightCurvePlot['pgplotHandle'] = ppgplot.pgopen('/xs')
ppgplot.pgpap(8, 0.618)
ppgplot.pgenv(0., lightCurve.period, 0.0, 1.0, 0, 0)
ppgplot.pglab("seconds", "brightness", "Light curve")
ppgplot.pgpt(lightCurve.time, lightCurve.brightness, 2)
ppgplot.pgsci(2)
ppgplot.pgline(lightCurve.time, lightCurve.brightness)
ppgplot.pgask(False)
connectedCount = 0
connectedBulbs = []
for b in bulbs:
print b
if b['connected'] == True:
connectedCount+= 1
connectedBulbs.append(b)
print b['label'], "is connected!"
print "Number of connected bulbs", connectedCount
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()
ppgplot.pglab("Phase", "PTF magnitude", "%s"%(arg.name))
ppgplot.pgsch(1.0)
ppgplot.pgpt(phases, mag)
ppgplot.pgerrb(2, phases, mag, err, 0)
ppgplot.pgerrb(4, phases, mag, err, 0)
ppgplot.pgsci(2)
model = modelledData.getColumn('mag')
model.extend(model)
ppgplot.pgsls(2)
ppgplot.pgslw(7)
ppgplot.pgline(phases, model)
"""
ppgplot.pgsch(1.6)
ppgplot.pgenv(0, 2, 0, maxFlux, 0, 0)
ppgplot.pglab("Phase", "PTF flux (mJy)", "%s"%(arg.name))
ppgplot.pgsch(1.0)
ppgplot.pgpt(phases, flux)
ppgplot.pgerrb(2, phases, flux, flux_err, 0)
ppgplot.pgerrb(4, phases, flux, flux_err, 0)
ppgplot.pgsci(2)
ppgplot.pgsls(2)
ppgplot.pgslw(7)
modelPhases = modelledData.getColumn('phase')
temp = copy.deepcopy(modelPhases)
for p in modelPhases: temp.append(p + 1.0)
modelPhases = temp
model = modelledData.getColumn('flux')
model = [m * 3631E3 for m in model]
model.extend(model)
if not arg.stacked:
mainPGPlotWindow = ppgplot.pgopen(arg.device)
ppgplot.pgask(True)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
yUpper = 2.5
yLower = -0.5
for spectrum in spectra:
ppgplot.pgsci(1)
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
lowerFlux = min(spectrum.flux)
upperFlux = max(spectrum.flux)
ppgplot.pgenv(lowerWavelength, upperWavelength, lowerFlux, upperFlux, 0, 0)
ppgplot.pgbin(spectrum.wavelengths, spectrum.flux)
if hasEphemeris:
ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "flux [%s]"%spectrum.fluxUnits, "%s [%f]"%(spectrum.objectName, spectrum.phase))
else:
ppgplot.pglab("wavelength [%s]"%spectrum.wavelengthUnits, "flux [%s]"%spectrum.fluxUnits, "%s [%s]"%(spectrum.objectName, spectrum.loadedFromFilename))
if arg.stacked:
mainPGPlotWindow = ppgplot.pgopen(arg.device)
ppgplot.pgask(True)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
yLower = -0.5
offset = 2.0
yUpper = numSpectra * offset
lowerWavelength = min(spectrum.wavelengths)
upperWavelength = max(spectrum.wavelengths)
ppgplot.pgpap(6.18, 1.618)
plotname = "QSVir-oc"
plotDevices = ["/xs", "%s.eps/ps"%plotname]
for plotDevice in plotDevices:
mainPGPlotWindow = ppgplot.pgopen(plotDevice)
pgPlotTransform = [0, 1, 0, 0, 0, 1]
ppgplot.pgpap(10, 0.618)
ppgplot.pgsci(1)
ppgplot.pgenv(min(cycles)*1.05, max(cycles)*1.05, min(ocs)*1.15, max(ocs)*1.15, 0, 0)
ppgplot.pgslw(1)
ppgplot.pgpt(cycles, ocs, 2)
ppgplot.pgslw(1)
ppgplot.pgerrb(2, cycles, ocs, ocErrors, 0)
ppgplot.pgerrb(4, cycles, ocs, ocErrors, 0)
ppgplot.pgsls(2)
ppgplot.pglab("Cycle number", "O-C (seconds)", "")
ppgplot.pgclos()
""""# Map some colours
oColours = []
for o in observatories:
index = o % len(colourMap)
colour = colourMap[index]
oColours.append(colour)
# print oColours"""
sys.exit()
# Break it down by observatory
allData = []
for index, o in enumerate(observatories):
addToExisting = False
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 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)
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)
else:
print '# Warning: no sources found to match ', src
os._exit(1)
if _do_grace:
# -- switch lists to arrays (should have done that to begin with) for pgplot
t = Numeric.array(date) # time (in days)
t = t - t0 # but relative to first date found
f = Numeric.array(flux) # flux
e = 3 * Numeric.array(ferr) # flux errors as 3 sigma
g = Numeric.array(freq) # freq
p = gracePlot.gracePlot()
p.plot(t, f, e, symbols=1)
p.title('Fluxes for ' + src)
p.xlabel('Days since ' + d0)
p.ylabel('Flux (Jy)')
for r in [[70, 100], [100, 120], [120, 250]]:
n, x, y, dy = get_range(t, f, e, g, r[0], r[1], cut)
if n: p.plot(x, y, dy, symbols=1)
p.hold(1)
elif _do_pgplot:
t = Numeric.array(date) # time (in days)
t = t - t0 # but relative to first date found
f = Numeric.array(flux) # flux
ppgplot.pgopen(pgp)
ppgplot.pgenv(0, 1500, 0, 80, 0, 1)
ppgplot.pglab('Days since %s' % d0, 'Flux(Jy)', 'Flux for %s' % src)
ppgplot.pgpt(t, f, 9)
ppgplot.pgline(t, f)
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()
k = 1.2807e-16 #erg K
l = N.arange(2000., 50000., 1000.) #wavelength in A
l = l * 1.e-8 #convert to cm
T = 40000. #K
B = 2. * h * c**2 / (l**5) / (N.exp(h * c / (l * k * T)) - 1) / 1.e14
l = l * 1.e4
xmin = 1.15 * min(l)
xmax = max(l)
ymin = min(B)
ymax = 1.2 * max(B)
my.psplotinit("blackbody.ps")
ppgplot.pgbox("", 0.0, 0, "", 0.0, 0)
ppgplot.pgenv(xmin, xmax, ymin, ymax, 0, 0)
ppgplot.pglab("Wavelength", "Energy Output/second", "")
ppgplot.pgsci(4)
ppgplot.pgline(l, B)
ppgplot.pgtext(.6, 3., 'Star A')
ppgplot.pgtext(.6, -.5, 'Blue')
#T=20000.#K
#B=2.*h*c**2/(l**5)/(N.exp(h*c/(l*k*T))-1)
l = (l * 1.e-4 + 20000e-8) * 1.e4
ppgplot.pgsci(2)
ppgplot.pgline(l, B)
ppgplot.pgtext(2.6, 3., 'Star B')
ppgplot.pgtext(3.6, -.5, 'Red')
ppgplot.pgsci(1)
ppgplot.pgend()