def plot_candidate_sheet(rating_objects, pdm_cand_id, cand_ratings, description):
plot_utils.beginplot("cand_rating_report%s(%d).ps" % (currdatetime.strftime('%y%m%d'),pdm_cand_id), vertical=True)
ppgplot.pgtext(0,1,"%d: %s" % (pdm_cand_id, description))
top = 0.5
first = True
for ratobj, rating in zip(rating_objects,cand_ratings):
if (top - PARASPACING) < 0:
if first:
#
# Add P, DM, subints, subbands?
#
pfd = rating_utils.get_pfd_by_cand_id(pdm_cand_id)
prof = rating_utils.prep_profile(pfd)
ppgplot.pgsvp(0.10, 0.90, 0.60, 0.90)
ppgplot.pgswin(0, NUMPHASE, 1.1*np.min(prof), 1.1*np.max(prof))
ppgplot.pgbox('BCNTS', 0.25,5,'BC',0.0,0)
onephase = np.linspace(0,1,prof.size, endpoint=False)
manyphase = np.resize(onephase,prof.size*NUMPHASE)+np.arange(0,NUMPHASE).repeat(prof.size)
ppgplot.pgline(manyphase, np.resize(prof, (NUMPHASE*prof.size,)))
first = False
plot_utils.nextpage(vertical=True)
ppgplot.pgtext(0,1,"%d: %s (cont'd)" % (pdm_cand_id, description))
top = 0.9
ppgplot.pgtext(0,top, '%s: %s' % (ratobj.name, rating))
top -= PARASPACING
if first:
pfd = rating_utils.get_pfd_by_cand_id(pdm_cand_id)
prof = rating_utils.prep_profile(pfd)
ppgplot.pgsvp(0.10, 0.90, 0.60, 0.90)
ppgplot.pgswin(0, NUMPHASE, 1.1*np.min(prof), 1.1*np.max(prof))
ppgplot.pgbox('BCNTS', 0.25,5,'BC',0.0,0)
ppgplot.pgline(np.linspace(0,NUMPHASE,prof.size*NUMPHASE), np.resize(prof, (NUMPHASE*prof.size,)))
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 createPGplotWindow(handle, width, height):
""" Set up the PGPLOT windows """
newPlot = {}
newPlot["pgplotHandle"] = ppgplot.pgopen("/xs")
ppgplot.pgpap(2, 1)
ppgplot.pgsvp(0.0, 1.0, 0.0, 1.0)
ppgplot.pgswin(0, width, 0, height)
return newPlot
def createPGplotWindow(handle, width, height):
""" Set up the PGPLOT windows """
newPlot = {}
newPlot['pgplotHandle'] = ppgplot.pgopen('/xs')
ppgplot.pgpap(2, 1)
ppgplot.pgsvp(0.0, 1.0, 0.0, 1.0)
ppgplot.pgswin(0, width, 0, height)
return newPlot
def plotdVdz():
nv = 3.
nr = 1.
ppgplot.pgbeg("dVdz.ps/vcps", 1, 1) #color port.
ppgplot.pgpap(8., 1.25)
ppgplot.pgpage
ppgplot.pgsch(1.2) #font size
ppgplot.pgslw(3) #line width
# 1st panel with symbols w/ stddev errorbars
x1 = .15
x2 = .45
x3 = .6
x4 = .95
y1 = .15
y2 = .425
y3 = .575
y4 = .85
xlabel = 14.1 - 14.
ylabel = 1.15
schdef = 1.2
slwdef = 4
ppgplot.pgsch(schdef)
xmin = 0.
xmax = 1.1
ymin = 0.
ymax = 1.2
ppgplot.pgsvp(x1, x4, y1, y4) #sets viewport
ppgplot.pgslw(slwdef) #line width
ppgplot.pgswin(xmin, xmax, ymin, ymax) #axes limits
ppgplot.pgbox('bcnst', .2, 2, 'bcvnst', .2, 2) #tickmarks and labeling
ppgplot.pgmtxt('b', 2.5, 0.5, 0.5, "z") #xlabel
ppgplot.pgmtxt('l', 2.6, 0.5, 0.5, "(1/DH)\u3\d c dV\dc\u/dv/d\gW")
z = N.arange(0., 5., .1)
beta = ((1 + z)**2 - 1) / ((1 + z)**2 + 1)
dV = N.zeros(len(z), 'd')
for i in range(len(z)):
#dz=dv/(1+z[i])*(1- ((1+z[i])**2 -1)/((1+z[i])**2+1))**(-2)
#z1=z[i]-0.5*dz
#z2=z[i]+0.5*dz
#dV[i]=my.dL(z2,h) - my.dL(z1,h)
dA = my.DA(z[i], h) * 206264. / 1000.
dV[i] = DH * (1 + z[i]) * (dA)**2 / (my.E(
z[i])) / (1 - beta[i])**2 / DH**3
#dV[i]=DH*(1+z[i])**2*(dA)**2/(my.E(z[i]))/DH**3#for comparison w/Hogg
if z[i] < 1:
print i, z[i], dV[i], dV[i]**(1. / 3.)
ppgplot.pgline(z, dV)
ppgplot.pgend()
def drawMask(mask):
print ("Drawing the mask.")
if "pgplotHandle" not in maskPlot.keys():
maskPlot["pgplotHandle"] = ppgplot.pgopen("/xs")
maskPlot["pgPlotTransform"] = [0, 1, 0, 0, 0, 1]
else:
ppgplot.pgslct(maskPlot["pgplotHandle"])
ppgplot.pgpap(paperSize, aspectRatio)
ppgplot.pgsvp(0.0, 1.0, 0.0, 1.0)
ppgplot.pgswin(0, width, 0, height)
ppgplot.pggray(mask, 0, width - 1, 0, height - 1, 0, 255, maskPlot["pgPlotTransform"])
ppgplot.pgslct(imagePlot["pgplotHandle"])
def drawMask(mask):
print("Drawing the mask.")
if 'pgplotHandle' not in maskPlot.keys():
maskPlot['pgplotHandle'] = ppgplot.pgopen('/xs')
maskPlot['pgPlotTransform'] = [0, 1, 0, 0, 0, 1]
else:
ppgplot.pgslct(maskPlot['pgplotHandle'])
ppgplot.pgpap(paperSize, aspectRatio)
ppgplot.pgsvp(0.0, 1.0, 0.0, 1.0)
ppgplot.pgswin(0, width, 0, height)
ppgplot.pggray(mask, 0, width - 1, 0, height - 1, 0, 255,
maskPlot['pgPlotTransform'])
ppgplot.pgslct(imagePlot['pgplotHandle'])
def plotngalsigmaradcuts():
nr = 1.
nv = 3.
bbJmax = -18.
ppgplot.pgbeg("ngalmhalo-radcut.ps/vcps", 1, 1) #color port.
ppgplot.pgpap(8., 1.25)
ppgplot.pgpage
ppgplot.pgsch(1.2) #font size
ppgplot.pgslw(3) #line width
# 1st panel with symbols w/ stddev errorbars
str1 = "R\dp\u < "
str2 = " R\dv\u"
x1 = .1
x2 = .45
x3 = .6
x4 = .95
y1 = .15
y2 = .425
y3 = .575
y4 = .85
xlabel = 14.25 - 14.
ylabel = 1.14
ppgplot.pgsvp(x1, x2, y3, y4) #sets viewport
g.cutonlbj(bbJmax)
#print "within plotradcuts, after cutonlbj, len(g.x1) = ",len(g.x1)
nr = 1.
c.measurengalcontam(nv, nr, g)
#print "nr = ",nr, " ave contam = ",N.average(c.contam)
sub1plotngalmcl(c.mass, c.membincut, c.obsmembincut)
ppgplot.pgsch(.8)
ppgplot.pgslw(3)
#label="R\dp\u < "+str(nr)+"R\dv\u"
label = str1 + str(nr) + str2
ppgplot.pgtext(xlabel, ylabel, label)
nr = .5
ppgplot.pgsvp(x1, x2, y1, y2) #sets viewport
#ppgplot.pgpanl(1,1)
c.measurengalcontam(nv, nr, g)
#print "nr = ",nr, " ave contam = ",N.average(c.contam)
sub1plotngalmcl(c.mass, c.membincut, c.obsmembincut)
label = str1 + str(nr) + str2
ppgplot.pgsch(.8)
ppgplot.pgslw(3)
ppgplot.pgtext(xlabel, ylabel, label)
ppgplot.pgend()
def dm_time_plot(dms, times, sigmas, dm_arr, sigma_arr, time_arr,
Total_observed_time, xwin):
"""
Plot DM vs Time.
"""
min_dm = Num.min(dms)
max_dm = Num.max(dms)
ppgplot.pgsvp(0.48, 0.97, 0.1, 0.54)
ppgplot.pgswin(0, Total_observed_time, min_dm, max_dm)
ppgplot.pgsch(0.8)
ppgplot.pgslw(3)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgslw(3)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "Time (s)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "DM (pc cm\u-3\d)")
snr_range = 12.0
cand_symbols = []
cand_symbols_group = []
for i in range(len(sigmas)):
if sigmas[i] > 20.00:
sigmas[i] = 20.0
cand_symbol = int((sigmas[i] - 5.0) / snr_range * 6.0 + 20.5)
cand_symbols.append(min(cand_symbol, 26))
cand_symbols = Num.array(cand_symbols)
for i in range(len(dm_arr)):
cand_symbol = int((sigma_arr[i] - 5.0) / snr_range * 6.0 + 20.5)
cand_symbols_group.append(min(cand_symbol, 26))
cand_symbols_group = Num.array(cand_symbols_group)
dms = Num.array(dms)
times = Num.array(times)
dm_arr = Num.array(dm_arr)
time_arr = Num.array(time_arr)
for ii in [26, 25, 24, 23, 22, 21, 20]:
inds = Num.nonzero(cand_symbols == ii)[0]
ppgplot.pgshls(1, 0.0, 0.5, 0.0)
ppgplot.pgpt(times[inds], dms[inds], ii)
for ii in [26, 25, 24, 23, 22, 21, 20]:
inds_1 = Num.nonzero(cand_symbols_group == ii)[0]
if xwin:
ppgplot.pgshls(1, 0.0, 0.8, 0.0)
else:
ppgplot.pgshls(1, 0.0, 0.0, 0.0)
ppgplot.pgpt(time_arr[inds_1], dm_arr[inds_1], ii)
def startPlotter(self):
if self.plotDeviceIsOpened:
raise ValueError("You already started a plot!")
devId = pgplot.pgopen(self.deviceName)
self.plotDeviceIsOpened = True
if not self.widthInches is None:
pgplot.pgpap(self.widthInches, self.yOnXRatio)
# For devices /xs, /xw, /png etc, should make the paper white and the ink black. Only for /ps does pgplot default to that.
#
deviceWithoutFile = self.deviceName.split('/')[-1]
if deviceWithoutFile == 'xs' or deviceWithoutFile == 'xw' or deviceWithoutFile == 'png':
pgplot.pgscr(0, 1.0, 1.0, 1.0)
pgplot.pgscr(1, 0.0, 0.0, 0.0)
pgplot.pgsvp(self._vXLo, self._vXHi, self._vYLo, self._vYHi)
if self.fixAspect:
pgplot.pgwnad(self.worldXLo, self.worldXHi, self.worldYLo,
self.worldYHi)
else:
pgplot.pgswin(self.worldXLo, self.worldXHi, self.worldYLo,
self.worldYHi)
pgplot.pgsfs(2)
pgplot.pgslw(1)
pgplot.pgsch(self._charHeight)
self._setColourRepresentations()
# Set up things so calling pgplot.pggray() won't overwrite the CR of any of the colours in self.colours.
#
(minCI, maxCI) = pgplot.pgqcir()
if minCI <= self.maxCI:
pgplot.pgscir(self.maxCI + 1, maxCI)
(xLoPixels, xHiPixels, yLoPixels, yHiPixels) = pgplot.pgqvsz(3)
(xLoInches, xHiInches, yLoInches, yHiInches) = pgplot.pgqvsz(1)
self.xPixelWorld = (xHiInches - xLoInches) / (xHiPixels - xLoPixels)
self.yPixelWorld = (yHiInches - yLoInches) / (yHiPixels - yLoPixels)
def dm_time_plot(dms, times, sigmas, dm_arr, sigma_arr, time_arr, Total_observed_time, xwin):
"""
Plot DM vs Time.
"""
min_dm = Num.min(dms)
max_dm = Num.max(dms)
ppgplot.pgsvp(0.48, 0.97, 0.1, 0.54)
ppgplot.pgswin(0, Total_observed_time, min_dm, max_dm)
ppgplot.pgsch(0.8)
ppgplot.pgslw(3)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgslw(3)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "Time (s)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "DM (pc cm\u-3\d)")
snr_range = 12.0
cand_symbols = []
cand_symbols_group = []
for i in range(len(sigmas)):
if sigmas[i] > 20.00:
sigmas[i] = 20.0
cand_symbol = int((sigmas[i] - 5.0)/snr_range * 6.0 + 20.5)
cand_symbols.append(min(cand_symbol, 26))
cand_symbols = Num.array(cand_symbols)
for i in range(len(dm_arr)):
cand_symbol = int((sigma_arr[i] - 5.0)/snr_range * 6.0 + 20.5)
cand_symbols_group.append(min(cand_symbol, 26))
cand_symbols_group = Num.array(cand_symbols_group)
dms = Num.array(dms)
times = Num.array(times)
dm_arr = Num.array(dm_arr)
time_arr = Num.array(time_arr)
for ii in [26, 25, 24, 23, 22, 21, 20]:
inds = Num.nonzero(cand_symbols == ii)[0]
ppgplot.pgshls(1, 0.0, 0.5, 0.0)
ppgplot.pgpt(times[inds], dms[inds], ii)
for ii in [26, 25, 24, 23, 22, 21, 20]:
inds_1 = Num.nonzero(cand_symbols_group == ii)[0]
if xwin:
ppgplot.pgshls(1, 0.0, 0.8, 0.0)
else:
ppgplot.pgshls(1, 0.0, 0.0, 0.0)
ppgplot.pgpt(time_arr[inds_1], dm_arr[inds_1], ii)
imageData = hdulist[0].data
wcsSolution = WCS(hdulist[0].header)
hdulist.close()
(height, width) = numpy.shape(imageData)
aspectRatio = float(height)/float(width)
print aspectRatio
""" Set up the PGPLOT windows """
imagePlot = {}
imagePlot['pgplotHandle'] = ppgplot.pgopen('/xs')
ppgplot.pgpap(paperSize, aspectRatio)
ppgplot.pgsvp(0.0, 1.0, 0.0, 1.0)
ppgplot.pgswin(0, width, 0, height)
# ppgplot.pgenv(0., width,0., height, 1, -2)
imagePlot['pgPlotTransform'] = [0, 1, 0, 0, 0, 1]
boostedImage = generalUtils.percentiles(imageData, 20, 99)
ppgplot.pggray(boostedImage, 0, width-1, 0, height-1, 0, 255, imagePlot['pgPlotTransform'])
# Determine the RA, DEC of the centre of the image, using the WCS solution found in the FITS header
imageCentre = [ width/2, height/2]
ra, dec = wcsSolution.all_pix2world([imageCentre], 1)[0]
imageData = hdulist[1].data
savedImageData = numpy.copy(imageData)
wcsSolution = WCS(hdulist[1].header)
hdulist.close()
(height, width) = numpy.shape(imageData)
aspectRatio = float(height) / float(width)
print(aspectRatio)
""" Set up the PGPLOT windows """
imagePlot = {}
imagePlot['pgplotHandle'] = ppgplot.pgopen('/xs')
ppgplot.pgpap(paperSize, aspectRatio)
ppgplot.pgsvp(0.0, 1.0, 0.0, 1.0)
ppgplot.pgswin(0, width, 0, height)
# ppgplot.pgenv(0., width,0., height, 1, -2)
imagePlot['pgPlotTransform'] = [0, 1, 0, 0, 0, 1]
boostedImage = generalUtils.percentiles(imageData, 20, 99)
ppgplot.pggray(boostedImage, 0, width - 1, 0, height - 1, 0, 255,
imagePlot['pgPlotTransform'])
# Determine the RA, DEC of the centre of the image, using the WCS solution found in the FITS header
imageCentre = [width / 2, height / 2]
ra, dec = wcsSolution.all_pix2world([imageCentre], 1)[0]
positionString = generalUtils.toSexagesimal((ra, dec))
image = 'antirainbow'
device = 'ffdot_combined.eps/VCPS'
device = '/XWIN'
labx = 'Fourier Frequency Offset (bins)'
laby = 'Fourier Frequency Derivative (bins)'
contours = num.asarray([0.1, 0.3, 0.5, 0.7, 0.9])
imfract = 0.65
margin = 0.08
ppgplot.pgopen(device)
ppgplot.pgpap(0.0, 1.0)
ppgplot.pgpage()
# Give z and w values and power change
ppgplot.pgsvp(margin + imfract, 1.0 - margin / 2, margin + imfract,
1.0 - margin / 2)
ppgplot.pgswin(0.0, 1.0, 0.0, 1.0)
ppgplot.pgtext(0.1, 0.8, "Frac Recovered" % frp)
ppgplot.pgtext(0.2, 0.65, "Power = %.3f" % frp)
ppgplot.pgtext(0.1, 0.4, "signal z = %.1f" % z)
ppgplot.pgtext(0.1, 0.25, "signal w = %.1f" % w)
# freq cut
ppgplot.pgsvp(margin, margin + imfract, margin + imfract, 1.0 - margin / 2)
ppgplot.pgswin(min(rs), max(rs), -0.1, 1.1)
ppgplot.pgbox("BCST", 0.0, 0, "BCNST", 0.0, 0)
ppgplot.pgline(rs, freqcut)
ppgplot.pgmtxt("L", 2.0, 0.5, 0.5, "Relative Power")
#fdot cut
ppgplot.pgsvp(margin + imfract, 1.0 - margin / 2, margin, margin + imfract)
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))
# Plot A (Airmass-Time)
########################
# 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
#####################################################################
#####################################################################
image='antirainbow'
device='ffdot_combined.eps/VCPS'
device='/XWIN'
labx='Fourier Frequency Offset (bins)'
laby='Fourier Frequency Derivative (bins)'
contours = num.asarray([0.1, 0.3, 0.5, 0.7, 0.9])
imfract = 0.65
margin = 0.08
ppgplot.pgopen(device)
ppgplot.pgpap(0.0, 1.0)
ppgplot.pgpage()
# Give z and w values and power change
ppgplot.pgsvp(margin+imfract, 1.0-margin/2, margin+imfract, 1.0-margin/2)
ppgplot.pgswin(0.0, 1.0, 0.0, 1.0)
ppgplot.pgtext(0.1, 0.8, "Frac Recovered" % frp)
ppgplot.pgtext(0.2, 0.65, "Power = %.3f" % frp)
ppgplot.pgtext(0.1, 0.4, "signal z = %.1f" % z)
ppgplot.pgtext(0.1, 0.25, "signal w = %.1f" % w)
# freq cut
ppgplot.pgsvp(margin, margin+imfract, margin+imfract, 1.0-margin/2)
ppgplot.pgswin(min(rs), max(rs), -0.1, 1.1)
ppgplot.pgbox("BCST", 0.0, 0, "BCNST", 0.0, 0)
ppgplot.pgline(rs, freqcut)
ppgplot.pgmtxt("L", 2.0, 0.5, 0.5, "Relative Power");
#fdot cut
ppgplot.pgsvp(margin+imfract, 1.0-margin/2, margin, margin+imfract)
def main():
parser = OptionParser(usage)
parser.add_option(
"-x",
"--xwin",
action="store_true",
dest="xwin",
default=False,
help="Don't make a postscript plot, just use an X-window")
parser.add_option("-p",
"--noplot",
action="store_false",
dest="makeplot",
default=True,
help="Look for pulses but do not generate a plot")
parser.add_option(
"-m",
"--maxwidth",
type="float",
dest="maxwidth",
default=0.0,
help="Set the max downsampling in sec (see below for default)")
parser.add_option("-t",
"--threshold",
type="float",
dest="threshold",
default=5.0,
help="Set a different threshold SNR (default=5.0)")
parser.add_option("-s",
"--start",
type="float",
dest="T_start",
default=0.0,
help="Only plot events occuring after this time (s)")
parser.add_option("-e",
"--end",
type="float",
dest="T_end",
default=1e9,
help="Only plot events occuring before this time (s)")
parser.add_option("-g",
"--glob",
type="string",
dest="globexp",
default=None,
help="Process the files from this glob expression")
parser.add_option("-f",
"--fast",
action="store_true",
dest="fast",
default=False,
help="Use a faster method of de-trending (2x speedup)")
(opts, args) = parser.parse_args()
if len(args) == 0:
if opts.globexp == None:
print full_usage
sys.exit(0)
else:
args = []
for globexp in opts.globexp.split():
args += glob.glob(globexp)
useffts = True
dosearch = True
if opts.xwin:
pgplot_device = "/XWIN"
else:
pgplot_device = ""
fftlen = 8192 # Should be a power-of-two for best speed
chunklen = 8000 # Must be at least max_downfact less than fftlen
detrendlen = 1000 # length of a linear piecewise chunk of data for detrending
blocks_per_chunk = chunklen / detrendlen
overlap = (fftlen - chunklen) / 2
worklen = chunklen + 2 * overlap # currently it is fftlen...
max_downfact = 30
default_downfacts = [2, 3, 4, 6, 9, 14, 20, 30, 45, 70, 100, 150]
if args[0].endswith(".singlepulse"):
filenmbase = args[0][:args[0].rfind(".singlepulse")]
dosearch = False
elif args[0].endswith(".dat"):
filenmbase = args[0][:args[0].rfind(".dat")]
else:
filenmbase = args[0]
# Don't do a search, just read results and plot
if not dosearch:
info, DMs, candlist, num_v_DMstr = \
read_singlepulse_files(args, opts.threshold, opts.T_start, opts.T_end)
orig_N, orig_dt = int(info.N), info.dt
obstime = orig_N * orig_dt
else:
DMs = []
candlist = []
num_v_DMstr = {}
# Loop over the input files
for filenm in args:
if filenm.endswith(".dat"):
filenmbase = filenm[:filenm.rfind(".dat")]
else:
filenmbase = filenm
info = infodata.infodata(filenmbase + ".inf")
DMstr = "%.2f" % info.DM
DMs.append(info.DM)
N, dt = int(info.N), info.dt
obstime = N * dt
# Choose the maximum width to search based on time instead
# of bins. This helps prevent increased S/N when the downsampling
# changes as the DM gets larger.
if opts.maxwidth > 0.0:
downfacts = [
x for x in default_downfacts if x * dt <= opts.maxwidth
]
else:
downfacts = [x for x in default_downfacts if x <= max_downfact]
if len(downfacts) == 0:
downfacts = [default_downfacts[0]]
if (filenm == args[0]):
orig_N = N
orig_dt = dt
if useffts:
fftd_kerns = make_fftd_kerns(downfacts, fftlen)
if info.breaks:
offregions = zip([x[1] for x in info.onoff[:-1]],
[x[0] for x in info.onoff[1:]])
outfile = open(filenmbase + '.singlepulse', mode='w')
# Compute the file length in detrendlens
roundN = N / detrendlen * detrendlen
numchunks = roundN / chunklen
# Read in the file
print 'Reading "%s"...' % filenm
timeseries = Num.fromfile(filenm, dtype=Num.float32, count=roundN)
# Split the timeseries into chunks for detrending
numblocks = roundN / detrendlen
timeseries.shape = (numblocks, detrendlen)
stds = Num.zeros(numblocks, dtype=Num.float64)
# de-trend the data one chunk at a time
print ' De-trending the data and computing statistics...'
for ii, chunk in enumerate(timeseries):
if opts.fast: # use median removal instead of detrending (2x speedup)
tmpchunk = chunk.copy()
tmpchunk.sort()
med = tmpchunk[detrendlen / 2]
chunk -= med
tmpchunk -= med
else:
# The detrend calls are the most expensive in the program
timeseries[ii] = scipy.signal.detrend(chunk, type='linear')
tmpchunk = timeseries[ii].copy()
tmpchunk.sort()
# The following gets rid of (hopefully) most of the
# outlying values (i.e. power dropouts and single pulses)
# If you throw out 5% (2.5% at bottom and 2.5% at top)
# of random gaussian deviates, the measured stdev is ~0.871
# of the true stdev. Thus the 1.0/0.871=1.148 correction below.
# The following is roughly .std() since we already removed the median
stds[ii] = Num.sqrt(
(tmpchunk[detrendlen / 40:-detrendlen / 40]**2.0).sum() /
(0.95 * detrendlen))
stds *= 1.148
# sort the standard deviations and separate those with
# very low or very high values
sort_stds = stds.copy()
sort_stds.sort()
# identify the differences with the larges values (this
# will split off the chunks with very low and very high stds
locut = (sort_stds[1:numblocks / 2 + 1] -
sort_stds[:numblocks / 2]).argmax() + 1
hicut = (sort_stds[numblocks / 2 + 1:] -
sort_stds[numblocks / 2:-1]).argmax() + numblocks / 2 - 2
std_stds = scipy.std(sort_stds[locut:hicut])
median_stds = sort_stds[(locut + hicut) / 2]
lo_std = median_stds - 4.0 * std_stds
hi_std = median_stds + 4.0 * std_stds
# Determine a list of "bad" chunks. We will not search these.
bad_blocks = Num.nonzero((stds < lo_std) | (stds > hi_std))[0]
print " pseudo-median block standard deviation = %.2f" % (
median_stds)
print " identified %d bad blocks out of %d (i.e. %.2f%%)" % \
(len(bad_blocks), len(stds),
100.0*float(len(bad_blocks))/float(len(stds)))
stds[bad_blocks] = median_stds
print " Now searching..."
# Now normalize all of the data and reshape it to 1-D
timeseries /= stds[:, Num.newaxis]
timeseries.shape = (roundN, )
# And set the data in the bad blocks to zeros
# Even though we don't search these parts, it is important
# because of the overlaps for the convolutions
for bad_block in bad_blocks:
loind, hiind = bad_block * detrendlen, (bad_block +
1) * detrendlen
timeseries[loind:hiind] = 0.0
# Convert to a set for faster lookups below
bad_blocks = set(bad_blocks)
# Step through the data
dm_candlist = []
for chunknum in range(numchunks):
loind = chunknum * chunklen - overlap
hiind = (chunknum + 1) * chunklen + overlap
# Take care of beginning and end of file overlap issues
if (chunknum == 0): # Beginning of file
chunk = Num.zeros(worklen, dtype=Num.float32)
chunk[overlap:] = timeseries[loind + overlap:hiind]
elif (chunknum == numchunks - 1): # end of the timeseries
chunk = Num.zeros(worklen, dtype=Num.float32)
chunk[:-overlap] = timeseries[loind:hiind - overlap]
else:
chunk = timeseries[loind:hiind]
# Make a set with the current block numbers
lowblock = blocks_per_chunk * chunknum
currentblocks = set(Num.arange(blocks_per_chunk) + lowblock)
localgoodblocks = Num.asarray(
list(currentblocks - bad_blocks)) - lowblock
# Search this chunk if it is not all bad
if len(localgoodblocks):
# This is the good part of the data (end effects removed)
goodchunk = chunk[overlap:-overlap]
# need to pass blocks/chunklen, localgoodblocks
# dm_candlist, dt, opts.threshold to cython routine
# Search non-downsampled data first
# NOTE: these nonzero() calls are some of the most
# expensive calls in the program. Best bet would
# probably be to simply iterate over the goodchunk
# in C and append to the candlist there.
hibins = Num.flatnonzero(goodchunk > opts.threshold)
hivals = goodchunk[hibins]
hibins += chunknum * chunklen
hiblocks = hibins / detrendlen
# Add the candidates (which are sorted by bin)
for bin, val, block in zip(hibins, hivals, hiblocks):
if block not in bad_blocks:
time = bin * dt
dm_candlist.append(
candidate(info.DM, val, time, bin, 1))
# Prepare our data for the convolution
if useffts: fftd_chunk = rfft(chunk, -1)
# Now do the downsampling...
for ii, downfact in enumerate(downfacts):
if useffts:
# Note: FFT convolution is faster for _all_ downfacts, even 2
goodchunk = fft_convolve(fftd_chunk,
fftd_kerns[ii], overlap,
-overlap)
else:
# The normalization of this kernel keeps the post-smoothing RMS = 1
kernel = Num.ones(downfact, dtype=Num.float32) / \
Num.sqrt(downfact)
smoothed_chunk = scipy.signal.convolve(
chunk, kernel, 1)
goodchunk = smoothed_chunk[overlap:-overlap]
#hibins = Num.nonzero(goodchunk>opts.threshold)[0]
hibins = Num.flatnonzero(goodchunk > opts.threshold)
hivals = goodchunk[hibins]
hibins += chunknum * chunklen
hiblocks = hibins / detrendlen
hibins = hibins.tolist()
hivals = hivals.tolist()
# Now walk through the new candidates and remove those
# that are not the highest but are within downfact/2
# bins of a higher signal pulse
hibins, hivals = prune_related1(
hibins, hivals, downfact)
# Insert the new candidates into the candlist, but
# keep it sorted...
for bin, val, block in zip(hibins, hivals, hiblocks):
if block not in bad_blocks:
time = bin * dt
bisect.insort(
dm_candlist,
candidate(info.DM, val, time, bin,
downfact))
# Now walk through the dm_candlist and remove the ones that
# are within the downsample proximity of a higher
# signal-to-noise pulse
dm_candlist = prune_related2(dm_candlist, downfacts)
print " Found %d pulse candidates" % len(dm_candlist)
# Get rid of those near padding regions
if info.breaks: prune_border_cases(dm_candlist, offregions)
# Write the pulses to an ASCII output file
if len(dm_candlist):
#dm_candlist.sort(cmp_sigma)
outfile.write(
"# DM Sigma Time (s) Sample Downfact\n")
for cand in dm_candlist:
outfile.write(str(cand))
outfile.close()
# Add these candidates to the overall candidate list
for cand in dm_candlist:
candlist.append(cand)
num_v_DMstr[DMstr] = len(dm_candlist)
if (opts.makeplot):
# Step through the candidates to make a SNR list
DMs.sort()
snrs = []
for cand in candlist:
snrs.append(cand.sigma)
if snrs:
maxsnr = max(int(max(snrs)), int(opts.threshold)) + 3
else:
maxsnr = int(opts.threshold) + 3
# Generate the SNR histogram
snrs = Num.asarray(snrs)
(num_v_snr, lo_snr, d_snr, num_out_of_range) = \
scipy.stats.histogram(snrs,
int(maxsnr-opts.threshold+1),
[opts.threshold, maxsnr])
snrs = Num.arange(maxsnr-opts.threshold+1, dtype=Num.float64) * d_snr \
+ lo_snr + 0.5*d_snr
num_v_snr = num_v_snr.astype(Num.float32)
num_v_snr[num_v_snr == 0.0] = 0.001
# Generate the DM histogram
num_v_DM = Num.zeros(len(DMs))
for ii, DM in enumerate(DMs):
num_v_DM[ii] = num_v_DMstr["%.2f" % DM]
DMs = Num.asarray(DMs)
# open the plot device
short_filenmbase = filenmbase[:filenmbase.find("_DM")]
if opts.T_end > obstime:
opts.T_end = obstime
if pgplot_device:
ppgplot.pgopen(pgplot_device)
else:
if (opts.T_start > 0.0 or opts.T_end < obstime):
ppgplot.pgopen(short_filenmbase +
'_%.0f-%.0fs_singlepulse.ps/VPS' %
(opts.T_start, opts.T_end))
else:
ppgplot.pgopen(short_filenmbase + '_singlepulse.ps/VPS')
ppgplot.pgpap(7.5, 1.0) # Width in inches, aspect
# plot the SNR histogram
ppgplot.pgsvp(0.06, 0.31, 0.6, 0.87)
ppgplot.pgswin(opts.threshold, maxsnr, Num.log10(0.5),
Num.log10(2 * max(num_v_snr)))
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCLNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "Signal-to-Noise")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "Number of Pulses")
ppgplot.pgsch(1.0)
ppgplot.pgbin(snrs, Num.log10(num_v_snr), 1)
# plot the DM histogram
ppgplot.pgsvp(0.39, 0.64, 0.6, 0.87)
# Add [1] to num_v_DM in YMAX below so that YMIN != YMAX when max(num_v_DM)==0
ppgplot.pgswin(
min(DMs) - 0.5,
max(DMs) + 0.5, 0.0, 1.1 * max(num_v_DM + [1]))
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "DM (pc cm\u-3\d)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "Number of Pulses")
ppgplot.pgsch(1.0)
ppgplot.pgbin(DMs, num_v_DM, 1)
# plot the SNR vs DM plot
ppgplot.pgsvp(0.72, 0.97, 0.6, 0.87)
ppgplot.pgswin(min(DMs) - 0.5, max(DMs) + 0.5, opts.threshold, maxsnr)
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "DM (pc cm\u-3\d)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "Signal-to-Noise")
ppgplot.pgsch(1.0)
cand_ts = Num.zeros(len(candlist), dtype=Num.float32)
cand_SNRs = Num.zeros(len(candlist), dtype=Num.float32)
cand_DMs = Num.zeros(len(candlist), dtype=Num.float32)
for ii, cand in enumerate(candlist):
cand_ts[ii], cand_SNRs[ii], cand_DMs[ii] = \
cand.time, cand.sigma, cand.DM
ppgplot.pgpt(cand_DMs, cand_SNRs, 20)
# plot the DM vs Time plot
ppgplot.pgsvp(0.06, 0.97, 0.08, 0.52)
ppgplot.pgswin(opts.T_start, opts.T_end,
min(DMs) - 0.5,
max(DMs) + 0.5)
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "Time (s)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "DM (pc cm\u-3\d)")
# Circles are symbols 20-26 in increasing order
snr_range = 12.0
cand_symbols = (cand_SNRs - opts.threshold) / snr_range * 6.0 + 20.5
cand_symbols = cand_symbols.astype(Num.int32)
cand_symbols[cand_symbols > 26] = 26
for ii in [26, 25, 24, 23, 22, 21, 20]:
inds = Num.nonzero(cand_symbols == ii)[0]
ppgplot.pgpt(cand_ts[inds], cand_DMs[inds], ii)
# Now fill the infomation area
ppgplot.pgsvp(0.05, 0.95, 0.87, 0.97)
ppgplot.pgsch(1.0)
ppgplot.pgmtxt('T', 0.5, 0.0, 0.0,
"Single pulse results for '%s'" % short_filenmbase)
ppgplot.pgsch(0.8)
# first row
ppgplot.pgmtxt('T', -1.1, 0.02, 0.0, 'Source: %s'%\
info.object)
ppgplot.pgmtxt('T', -1.1, 0.33, 0.0, 'RA (J2000):')
ppgplot.pgmtxt('T', -1.1, 0.5, 0.0, info.RA)
ppgplot.pgmtxt('T', -1.1, 0.73, 0.0, 'N samples: %.0f' % orig_N)
# second row
ppgplot.pgmtxt('T', -2.4, 0.02, 0.0, 'Telescope: %s'%\
info.telescope)
ppgplot.pgmtxt('T', -2.4, 0.33, 0.0, 'DEC (J2000):')
ppgplot.pgmtxt('T', -2.4, 0.5, 0.0, info.DEC)
ppgplot.pgmtxt('T', -2.4, 0.73, 0.0, 'Sampling time: %.2f \gms'%\
(orig_dt*1e6))
# third row
if info.instrument.find("pigot") >= 0:
instrument = "Spigot"
else:
instrument = info.instrument
ppgplot.pgmtxt('T', -3.7, 0.02, 0.0, 'Instrument: %s' % instrument)
if (info.bary):
ppgplot.pgmtxt('T', -3.7, 0.33, 0.0,
'MJD\dbary\u: %.12f' % info.epoch)
else:
ppgplot.pgmtxt('T', -3.7, 0.33, 0.0,
'MJD\dtopo\u: %.12f' % info.epoch)
ppgplot.pgmtxt('T', -3.7, 0.73, 0.0, 'Freq\dctr\u: %.1f MHz'%\
((info.numchan/2-0.5)*info.chan_width+info.lofreq))
ppgplot.pgiden()
ppgplot.pgend()
ppgplot.pgopen("/xs")
ppgplot.pgslw(2)
ppgplot.pgpap(0.0, 0.75)
# For ever loop
redraw = True
while True:
# Redraw
if redraw == True:
# Update
m.update()
# Initialize window
ppgplot.pgscr(0, 0., 0., 0.)
ppgplot.pgeras()
ppgplot.pgsvp(0.01, 0.99, 0.01, 0.99)
ppgplot.pgwnad(-1.5 * m.w, 1.5 * m.w, -m.w, m.w)
# Set background depending on solar altitude
if m.sunalt > 0.0:
ppgplot.pgscr(0, 0.0, 0.0, 0.4)
elif m.sunalt > -6.0:
ppgplot.pgscr(0, 0.0, 0.0, 0.3)
elif m.sunalt > -12.0:
ppgplot.pgscr(0, 0.0, 0.0, 0.2)
elif m.sunalt > -18.0:
ppgplot.pgscr(0, 0.0, 0.0, 0.1)
else:
ppgplot.pgscr(0, 0.0, 0.0, 0.0)
ppgplot.pgsci(0)
def mratiopg():
ppgplot.pgbeg("maccratio.ps/vcps",1,1) #color port.
ppgplot.pgpap(8.,1.)
ppgplot.pgpage
ppgplot.pgsch(1.3) #font size
ppgplot.pgslw(7) #line width
# 1st panel with symbols w/ stddev errorbars
#ylabel="SFR (M\d\(2281) \u yr\u-1\d)"
ylabel="L(H\ga) (10\u41\d erg s\u-1\d)"
xlabel="M\dr\u "
x1=.15
x2=.5
x3=.5
x4=.85
y1=x1
y2=x2
y3=x3
y4=x4
emarker=18
smarker=23
xmin=N.log10(1.e14)
xmax=N.log10(2.5e15)
#ymin=-1.
#ymax=3.
ymin=0.
ymax=25.
ppgplot.pgsvp(x1,x4,y1,y4) #sets viewport
ppgplot.pgswin(xmin,xmax,ymin,ymax) #axes limits
ppgplot.pgbox('blncst',1.,2,'bcvnst',2.,2) #tickmarks and labeling
for i in range(len(lz1lm.mass)):
m=lz1lm.mass[i]
l=lz1lm.maccret[i]
h=hz1lm.maccret[i]
r=h/l
print i,m,l,h,r
#print lz1lm.maccret
#print hz1lm.maccret
#print hz3lm.maccret
r3lm=(hz3lm.maccret)/(lz3lm.maccret)
r3hm=(hz3hm.maccret)/(lz3hm.maccret)
#for i in range(len(r3)):
# print i,lz3.sigma[i],hz3.sigma[i],lz3.mass[i],hz3.mass[i]
# print i,lz01.sigma[i],hz01.sigma[i],lz01.mass[i],hz01.mass[i]
r1lm=hz1lm.maccret/lz1lm.maccret
r1hm=hz1hm.maccret/lz1hm.maccret
#ra=N.array(hz01.maccret,'d')
#rb=N.array(lz01.maccret,'d')
#r01=ra/rb
#for i in range(len(r01)):
#print "ratio ",hz01.maccret[i],lz01.maccret[i],ra[i],rb[i],r01[i]
ppgplot.pgsci(14)
ppgplot.pgsls(1)
ppgplot.pgline(N.log10(lz3lm.mass),r3lm)
ppgplot.pgsls(2)
ppgplot.pgline(N.log10(lz3hm.mass),r3hm)
ppgplot.pgsci(1)
ppgplot.pgsls(1)
ppgplot.pgline(N.log10(lz1lm.mass),r1lm)
ppgplot.pgsls(2)
ppgplot.pgline(N.log10(lz1hm.mass),r1hm)
xlabel='M\dcl\u (M\d\(2281)\u)'
ylabel='M\dacc\u(z=0.75) / M\dacc\u(z=0.07)'
ppgplot.pgsch(1.8)
ppgplot.pgslw(7)
ppgplot.pgmtxt('b',2.2,0.5,0.5,ylabel) #xlabel
ppgplot.pgmtxt('l',2.5,0.5,0.5,xlabel)
ppgplot.pgend()
subPhases.append(phase)
subFluxErr.append(flux_err[index])
for index, phase in enumerate(modelPhases):
if phase > startPhase and phase < endPhase:
subModel.append(model[index])
subModelPhases.append(phase)
print ppgplot.pgqvp(0)
(x1, x2, y1, y2) = ppgplot.pgqvp(0)
print ppgplot.pgqwin(0)
xlower = (x1 + x2) / 2 + 0.05
xupper = x2 - 0.05
yupper = (y1 + y2) / 2
ylower = 0.22
ppgplot.pgsvp(xlower, xupper, ylower, yupper)
ppgplot.pgswin(startPhase, endPhase, 0, numpy.max(subFlux))
print ppgplot.pgqvp(0)
print ppgplot.pgqwin(0)
# ppgplot.pgsubp(4, 3)
# ppgplot.pgpanl(2, 2)
# ppgplot.pgenv(startPhase, endPhase, 0, numpy.max(flux), 0, -1)
# ppgplot.pglab("Phase", "PTF flux", "%s"%(arg.name))
ppgplot.pgbox("BCN", 0, 0, "BC", 0, 0)
ppgplot.pgpt(subPhases, subFlux)
ppgplot.pgerrb(2, subPhases, subFlux, subFluxErr, 0)
ppgplot.pgerrb(4, subPhases, subFlux, subFluxErr, 0)
ppgplot.pgsls(2)
ppgplot.pgline(subModelPhases, subModel)
ppgplot.pgsls(4)
def joy_division_plot(pulses, timeseries, downfactor=1, hgt_mult=1):
"""Plot each pulse profile on the same plot separated
slightly on the vertical axis.
'timeseries' is the Datfile object dissected.
Downsample profiles by factor 'downfactor' before plotting.
hgt_mult is a factor to stretch the height of the paper.
"""
first = True
ppgplot.pgbeg("%s.joydiv.ps/CPS" % \
os.path.split(timeseries.basefn)[1], 1, 1)
ppgplot.pgpap(10.25, hgt_mult*8.5/11.0) # Letter landscape
# ppgplot.pgpap(7.5, 11.7/8.3) # A4 portrait, doesn't print properly
ppgplot.pgiden()
ppgplot.pgsci(1)
# Set up main plot
ppgplot.pgsvp(0.1, 0.9, 0.1, 0.8)
ppgplot.pglab("Profile bin", "Single pulse profiles", "")
to_plot = []
xmin = 0
xmax = None
ymin = None
ymax = None
for pulse in pulses:
vertical_offset = (pulse.number-1)*JOYDIV_SEP
copy_of_pulse = pulse.make_copy()
if downfactor > 1:
# Interpolate before downsampling
interp = ((copy_of_pulse.N/downfactor)+1)*downfactor
copy_of_pulse.interpolate(interp)
copy_of_pulse.downsample(downfactor)
# copy_of_pulse.scale()
if first:
summed_prof = copy_of_pulse.profile.copy()
first = False
else:
summed_prof += copy_of_pulse.profile
prof = copy_of_pulse.profile + vertical_offset
min = prof.min()
if ymin is None or min < ymin:
ymin = min
max = prof.max()
if ymax is None or max > ymax:
ymax = max
max = prof.size-1
if xmax is None or max > xmax:
xmax = max
to_plot.append(prof)
yspace = 0.1*ymax
ppgplot.pgswin(0, xmax, ymin-yspace, ymax+yspace)
for prof in to_plot:
ppgplot.pgline(np.arange(0,prof.size), prof)
ppgplot.pgbox("BNTS", 0, 0, "BC", 0, 0)
# Set up summed profile plot
ppgplot.pgsvp(0.1, 0.9, 0.8, 0.9)
ppgplot.pglab("", "Summed profile", "Pulses from %s" % timeseries.datfn)
summed_prof = summed_prof - summed_prof.mean()
ppgplot.pgswin(0, xmax, summed_prof.min(), summed_prof.max())
ppgplot.pgline(np.arange(0, summed_prof.size), summed_prof)
ppgplot.pgbox("C", 0, 0, "BC", 0, 0)
ppgplot.pgclos()
def main():
parser = OptionParser(usage)
parser.add_option("-x", "--xwin", action="store_true", dest="xwin",
default=False, help="Don't make a postscript plot, just use an X-window")
parser.add_option("-p", "--noplot", action="store_false", dest="makeplot",
default=True, help="Look for pulses but do not generate a plot")
parser.add_option("-m", "--maxwidth", type="float", dest="maxwidth", default=0.0,
help="Set the max downsampling in sec (see below for default)")
parser.add_option("-t", "--threshold", type="float", dest="threshold", default=5.0,
help="Set a different threshold SNR (default=5.0)")
parser.add_option("-s", "--start", type="float", dest="T_start", default=0.0,
help="Only plot events occuring after this time (s)")
parser.add_option("-e", "--end", type="float", dest="T_end", default=1e9,
help="Only plot events occuring before this time (s)")
parser.add_option("-g", "--glob", type="string", dest="globexp", default=None,
help="Process the files from this glob expression")
parser.add_option("-f", "--fast", action="store_true", dest="fast",
default=False, help="Use a faster method of de-trending (2x speedup)")
parser.add_option("-b", "--nobadblocks", action="store_false", dest="badblocks",
default=True, help="Don't check for bad-blocks (may save strong pulses)")
parser.add_option("-d", "--detrendlen", type="int", dest="detrendfact", default=1,
help="Chunksize for detrending (pow-of-2 in 1000s)")
(opts, args) = parser.parse_args()
if len(args)==0:
if opts.globexp==None:
print full_usage
sys.exit(0)
else:
args = []
for globexp in opts.globexp.split():
args += glob.glob(globexp)
useffts = True
dosearch = True
if opts.xwin:
pgplot_device = "/XWIN"
else:
pgplot_device = ""
fftlen = 8192 # Should be a power-of-two for best speed
chunklen = 8000 # Must be at least max_downfact less than fftlen
assert(opts.detrendfact in [1,2,4,8,16,32])
detrendlen = opts.detrendfact*1000
if (detrendlen > chunklen):
chunklen = detrendlen
fftlen = int(next2_to_n(chunklen))
blocks_per_chunk = chunklen / detrendlen
overlap = (fftlen - chunklen)/2
worklen = chunklen + 2*overlap # currently it is fftlen...
max_downfact = 30
default_downfacts = [2, 3, 4, 6, 9, 14, 20, 30, 45, 70, 100, 150, 220, 300]
if args[0].endswith(".singlepulse"):
filenmbase = args[0][:args[0].rfind(".singlepulse")]
dosearch = False
elif args[0].endswith(".dat"):
filenmbase = args[0][:args[0].rfind(".dat")]
else:
filenmbase = args[0]
# Don't do a search, just read results and plot
if not dosearch:
info, DMs, candlist, num_v_DMstr = \
read_singlepulse_files(args, opts.threshold, opts.T_start, opts.T_end)
orig_N, orig_dt = int(info.N), info.dt
obstime = orig_N * orig_dt
else:
DMs = []
candlist = []
num_v_DMstr = {}
# Loop over the input files
for filenm in args:
if filenm.endswith(".dat"):
filenmbase = filenm[:filenm.rfind(".dat")]
else:
filenmbase = filenm
info = infodata.infodata(filenmbase+".inf")
DMstr = "%.2f"%info.DM
DMs.append(info.DM)
N, dt = int(info.N), info.dt
obstime = N * dt
# Choose the maximum width to search based on time instead
# of bins. This helps prevent increased S/N when the downsampling
# changes as the DM gets larger.
if opts.maxwidth > 0.0:
downfacts = [x for x in default_downfacts if x*dt <= opts.maxwidth]
else:
downfacts = [x for x in default_downfacts if x <= max_downfact]
if len(downfacts) == 0:
downfacts = [default_downfacts[0]]
if (filenm == args[0]):
orig_N = N
orig_dt = dt
if info.breaks:
offregions = zip([x[1] for x in info.onoff[:-1]],
[x[0] for x in info.onoff[1:]])
# If last break spans to end of file, don't read it in (its just padding)
if offregions[-1][1] == N - 1:
N = offregions[-1][0] + 1
outfile = open(filenmbase+'.singlepulse', mode='w')
# Compute the file length in detrendlens
roundN = N/detrendlen * detrendlen
numchunks = roundN / chunklen
# Read in the file
print 'Reading "%s"...'%filenm
timeseries = Num.fromfile(filenm, dtype=Num.float32, count=roundN)
# Split the timeseries into chunks for detrending
numblocks = roundN/detrendlen
timeseries.shape = (numblocks, detrendlen)
stds = Num.zeros(numblocks, dtype=Num.float64)
# de-trend the data one chunk at a time
print ' De-trending the data and computing statistics...'
for ii, chunk in enumerate(timeseries):
if opts.fast: # use median removal instead of detrending (2x speedup)
tmpchunk = chunk.copy()
tmpchunk.sort()
med = tmpchunk[detrendlen/2]
chunk -= med
tmpchunk -= med
else:
# The detrend calls are the most expensive in the program
timeseries[ii] = scipy.signal.detrend(chunk, type='linear')
tmpchunk = timeseries[ii].copy()
tmpchunk.sort()
# The following gets rid of (hopefully) most of the
# outlying values (i.e. power dropouts and single pulses)
# If you throw out 5% (2.5% at bottom and 2.5% at top)
# of random gaussian deviates, the measured stdev is ~0.871
# of the true stdev. Thus the 1.0/0.871=1.148 correction below.
# The following is roughly .std() since we already removed the median
stds[ii] = Num.sqrt((tmpchunk[detrendlen/40:-detrendlen/40]**2.0).sum() /
(0.95*detrendlen))
stds *= 1.148
# sort the standard deviations and separate those with
# very low or very high values
sort_stds = stds.copy()
sort_stds.sort()
# identify the differences with the larges values (this
# will split off the chunks with very low and very high stds
locut = (sort_stds[1:numblocks/2+1] -
sort_stds[:numblocks/2]).argmax() + 1
hicut = (sort_stds[numblocks/2+1:] -
sort_stds[numblocks/2:-1]).argmax() + numblocks/2 - 2
std_stds = scipy.std(sort_stds[locut:hicut])
median_stds = sort_stds[(locut+hicut)/2]
print " pseudo-median block standard deviation = %.2f" % (median_stds)
if (opts.badblocks):
lo_std = median_stds - 4.0 * std_stds
hi_std = median_stds + 4.0 * std_stds
# Determine a list of "bad" chunks. We will not search these.
bad_blocks = Num.nonzero((stds < lo_std) | (stds > hi_std))[0]
print " identified %d bad blocks out of %d (i.e. %.2f%%)" % \
(len(bad_blocks), len(stds),
100.0*float(len(bad_blocks))/float(len(stds)))
stds[bad_blocks] = median_stds
else:
bad_blocks = []
print " Now searching..."
# Now normalize all of the data and reshape it to 1-D
timeseries /= stds[:,Num.newaxis]
timeseries.shape = (roundN,)
# And set the data in the bad blocks to zeros
# Even though we don't search these parts, it is important
# because of the overlaps for the convolutions
for bad_block in bad_blocks:
loind, hiind = bad_block*detrendlen, (bad_block+1)*detrendlen
timeseries[loind:hiind] = 0.0
# Convert to a set for faster lookups below
bad_blocks = set(bad_blocks)
# Step through the data
dm_candlist = []
for chunknum in xrange(numchunks):
loind = chunknum*chunklen-overlap
hiind = (chunknum+1)*chunklen+overlap
# Take care of beginning and end of file overlap issues
if (chunknum==0): # Beginning of file
chunk = Num.zeros(worklen, dtype=Num.float32)
chunk[overlap:] = timeseries[loind+overlap:hiind]
elif (chunknum==numchunks-1): # end of the timeseries
chunk = Num.zeros(worklen, dtype=Num.float32)
chunk[:-overlap] = timeseries[loind:hiind-overlap]
else:
chunk = timeseries[loind:hiind]
# Make a set with the current block numbers
lowblock = blocks_per_chunk * chunknum
currentblocks = set(Num.arange(blocks_per_chunk) + lowblock)
localgoodblocks = Num.asarray(list(currentblocks -
bad_blocks)) - lowblock
# Search this chunk if it is not all bad
if len(localgoodblocks):
# This is the good part of the data (end effects removed)
goodchunk = chunk[overlap:-overlap]
# need to pass blocks/chunklen, localgoodblocks
# dm_candlist, dt, opts.threshold to cython routine
# Search non-downsampled data first
# NOTE: these nonzero() calls are some of the most
# expensive calls in the program. Best bet would
# probably be to simply iterate over the goodchunk
# in C and append to the candlist there.
hibins = Num.flatnonzero(goodchunk>opts.threshold)
hivals = goodchunk[hibins]
hibins += chunknum * chunklen
hiblocks = hibins/detrendlen
# Add the candidates (which are sorted by bin)
for bin, val, block in zip(hibins, hivals, hiblocks):
if block not in bad_blocks:
time = bin * dt
dm_candlist.append(candidate(info.DM, val, time, bin, 1))
# Now do the downsampling...
for downfact in downfacts:
if useffts:
# Note: FFT convolution is faster for _all_ downfacts, even 2
chunk2 = Num.concatenate((Num.zeros(1000), chunk, Num.zeros(1000)))
goodchunk = Num.convolve(chunk2, Num.ones(downfact), mode='same') / Num.sqrt(downfact)
goodchunk = goodchunk[overlap:-overlap]
#O qualcosa di simile, altrimenti non so perche' trova piu' candidati! Controllare!
else:
# The normalization of this kernel keeps the post-smoothing RMS = 1
kernel = Num.ones(downfact, dtype=Num.float32) / \
Num.sqrt(downfact)
smoothed_chunk = scipy.signal.convolve(chunk, kernel, 1)
goodchunk = smoothed_chunk[overlap:-overlap]
#hibins = Num.nonzero(goodchunk>opts.threshold)[0]
hibins = Num.flatnonzero(goodchunk>opts.threshold)
hivals = goodchunk[hibins]
hibins += chunknum * chunklen
hiblocks = hibins/detrendlen
hibins = hibins.tolist()
hivals = hivals.tolist()
# Now walk through the new candidates and remove those
# that are not the highest but are within downfact/2
# bins of a higher signal pulse
hibins, hivals = prune_related1(hibins, hivals, downfact)
# Insert the new candidates into the candlist, but
# keep it sorted...
for bin, val, block in zip(hibins, hivals, hiblocks):
if block not in bad_blocks:
time = bin * dt
bisect.insort(dm_candlist,
candidate(info.DM, val, time, bin, downfact))
# Now walk through the dm_candlist and remove the ones that
# are within the downsample proximity of a higher
# signal-to-noise pulse
dm_candlist = prune_related2(dm_candlist, downfacts)
print " Found %d pulse candidates"%len(dm_candlist)
# Get rid of those near padding regions
if info.breaks: prune_border_cases(dm_candlist, offregions)
# Write the pulses to an ASCII output file
if len(dm_candlist):
#dm_candlist.sort(cmp_sigma)
outfile.write("# DM Sigma Time (s) Sample Downfact\n")
for cand in dm_candlist:
outfile.write(str(cand))
outfile.close()
# Add these candidates to the overall candidate list
for cand in dm_candlist:
candlist.append(cand)
num_v_DMstr[DMstr] = len(dm_candlist)
if (opts.makeplot):
# Step through the candidates to make a SNR list
DMs.sort()
snrs = []
for cand in candlist:
if not Num.isinf(cand.sigma):
snrs.append(cand.sigma)
if snrs:
maxsnr = max(int(max(snrs)), int(opts.threshold)) + 3
else:
maxsnr = int(opts.threshold) + 3
# Generate the SNR histogram
snrs = Num.asarray(snrs)
(num_v_snr, lo_snr, d_snr, num_out_of_range) = \
scipy.stats.histogram(snrs,
int(maxsnr-opts.threshold+1),
[opts.threshold, maxsnr])
snrs = Num.arange(maxsnr-opts.threshold+1, dtype=Num.float64) * d_snr \
+ lo_snr + 0.5*d_snr
num_v_snr = num_v_snr.astype(Num.float32)
num_v_snr[num_v_snr==0.0] = 0.001
# Generate the DM histogram
num_v_DM = Num.zeros(len(DMs))
for ii, DM in enumerate(DMs):
num_v_DM[ii] = num_v_DMstr["%.2f"%DM]
DMs = Num.asarray(DMs)
# open the plot device
short_filenmbase = filenmbase[:filenmbase.find("_DM")]
if opts.T_end > obstime:
opts.T_end = obstime
if pgplot_device:
ppgplot.pgopen(pgplot_device)
else:
if (opts.T_start > 0.0 or opts.T_end < obstime):
ppgplot.pgopen(short_filenmbase+'_%.0f-%.0fs_singlepulse.ps/VPS'%
(opts.T_start, opts.T_end))
else:
ppgplot.pgopen(short_filenmbase+'_singlepulse.ps/VPS')
ppgplot.pgpap(7.5, 1.0) # Width in inches, aspect
# plot the SNR histogram
ppgplot.pgsvp(0.06, 0.31, 0.6, 0.87)
ppgplot.pgswin(opts.threshold, maxsnr,
Num.log10(0.5), Num.log10(2*max(num_v_snr)))
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCLNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "Signal-to-Noise")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "Number of Pulses")
ppgplot.pgsch(1.0)
ppgplot.pgbin(snrs, Num.log10(num_v_snr), 1)
# plot the DM histogram
ppgplot.pgsvp(0.39, 0.64, 0.6, 0.87)
# Add [1] to num_v_DM in YMAX below so that YMIN != YMAX when max(num_v_DM)==0
ppgplot.pgswin(min(DMs)-0.5, max(DMs)+0.5, 0.0, 1.1*max(num_v_DM+[1]))
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "DM (pc cm\u-3\d)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "Number of Pulses")
ppgplot.pgsch(1.0)
ppgplot.pgbin(DMs, num_v_DM, 1)
# plot the SNR vs DM plot
ppgplot.pgsvp(0.72, 0.97, 0.6, 0.87)
ppgplot.pgswin(min(DMs)-0.5, max(DMs)+0.5, opts.threshold, maxsnr)
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "DM (pc cm\u-3\d)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "Signal-to-Noise")
ppgplot.pgsch(1.0)
cand_ts = Num.zeros(len(candlist), dtype=Num.float32)
cand_SNRs = Num.zeros(len(candlist), dtype=Num.float32)
cand_DMs = Num.zeros(len(candlist), dtype=Num.float32)
for ii, cand in enumerate(candlist):
cand_ts[ii], cand_SNRs[ii], cand_DMs[ii] = \
cand.time, cand.sigma, cand.DM
ppgplot.pgpt(cand_DMs, cand_SNRs, 20)
# plot the DM vs Time plot
ppgplot.pgsvp(0.06, 0.97, 0.08, 0.52)
ppgplot.pgswin(opts.T_start, opts.T_end, min(DMs)-0.5, max(DMs)+0.5)
ppgplot.pgsch(0.8)
ppgplot.pgbox("BCNST", 0, 0, "BCNST", 0, 0)
ppgplot.pgmtxt('B', 2.5, 0.5, 0.5, "Time (s)")
ppgplot.pgmtxt('L', 1.8, 0.5, 0.5, "DM (pc cm\u-3\d)")
# Circles are symbols 20-26 in increasing order
snr_range = 12.0
cand_symbols = (cand_SNRs-opts.threshold)/snr_range * 6.0 + 20.5
cand_symbols = cand_symbols.astype(Num.int32)
cand_symbols[cand_symbols>26] = 26
for ii in [26, 25, 24, 23, 22, 21, 20]:
inds = Num.nonzero(cand_symbols==ii)[0]
ppgplot.pgpt(cand_ts[inds], cand_DMs[inds], ii)
# Now fill the infomation area
ppgplot.pgsvp(0.05, 0.95, 0.87, 0.97)
ppgplot.pgsch(1.0)
ppgplot.pgmtxt('T', 0.5, 0.0, 0.0,
"Single pulse results for '%s'"%short_filenmbase)
ppgplot.pgsch(0.8)
# first row
ppgplot.pgmtxt('T', -1.1, 0.02, 0.0, 'Source: %s'%\
info.object)
ppgplot.pgmtxt('T', -1.1, 0.33, 0.0, 'RA (J2000):')
ppgplot.pgmtxt('T', -1.1, 0.5, 0.0, info.RA)
ppgplot.pgmtxt('T', -1.1, 0.73, 0.0, 'N samples: %.0f'%orig_N)
# second row
ppgplot.pgmtxt('T', -2.4, 0.02, 0.0, 'Telescope: %s'%\
info.telescope)
ppgplot.pgmtxt('T', -2.4, 0.33, 0.0, 'DEC (J2000):')
ppgplot.pgmtxt('T', -2.4, 0.5, 0.0, info.DEC)
ppgplot.pgmtxt('T', -2.4, 0.73, 0.0, 'Sampling time: %.2f \gms'%\
(orig_dt*1e6))
# third row
if info.instrument.find("pigot") >= 0:
instrument = "Spigot"
else:
instrument = info.instrument
ppgplot.pgmtxt('T', -3.7, 0.02, 0.0, 'Instrument: %s'%instrument)
if (info.bary):
ppgplot.pgmtxt('T', -3.7, 0.33, 0.0, 'MJD\dbary\u: %.12f'%info.epoch)
else:
ppgplot.pgmtxt('T', -3.7, 0.33, 0.0, 'MJD\dtopo\u: %.12f'%info.epoch)
ppgplot.pgmtxt('T', -3.7, 0.73, 0.0, 'Freq\dctr\u: %.1f MHz'%\
((info.numchan/2-0.5)*info.chan_width+info.lofreq))
ppgplot.pgiden()
ppgplot.pgend()
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()
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
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)
if (arg.watch!=None) and (arg.watch<numReferenceApertures):
watch = arg.watch
watchView = {}
watchView['pgplotHandle'] = ppgplot.pgopen('/xs')
ppgplot.pgpap(10, 1)
ppgplot.pgsvp(0.1, 0.7, 0.3, 0.9)
ppgplot.pgswin(-margins, margins, -margins, margins)
# ppgplot.pgenv(-margins, margins, -margins, margins, 1, 0)
# ppgplot.pgenv(-margins, margins, 0, 10, 0, 0)
watchView['pgPlotTransform'] = [-11, 1, 0, -11, 0, 1]
else:
watch=-1
""" End of PGPLOT set up """
frameFlags = []
xValues = []
yValues = []
yAxisMax= 100
for frameIndex in range(2, frameRange + 1):
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()
