Esempio n. 1
0
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)
Esempio n. 2
0
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)
Esempio n. 3
0
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
Esempio n. 5
0
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)
Esempio n. 6
0
    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
Esempio n. 7
0
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/.')
Esempio n. 8
0
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()
Esempio n. 9
0
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()
Esempio n. 10
0
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)
Esempio n. 11
0
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]
Esempio n. 12
0
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()
Esempio n. 13
0
#! /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()
Esempio n. 14
0
########################
# 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
Esempio n. 15
0
		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)
Esempio n. 16
0
    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'
Esempio n. 18
0
# /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()
Esempio n. 19
0
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()
Esempio n. 20
0
	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 
	##########################################################################################################################
Esempio n. 21
0
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()
Esempio n. 22
0
		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)
	
	
Esempio n. 23
0
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)
Esempio n. 24
0
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)
	
Esempio n. 26
0
	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]
Esempio n. 27
0
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()
Esempio n. 28
0
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
Esempio n. 29
0
#/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()
Esempio n. 30
0
    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)
Esempio n. 31
0
	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)
		
		
		
	
Esempio n. 32
0
	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))
Esempio n. 34
0
	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
Esempio n. 35
0
	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")
		
Esempio n. 36
0
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()
Esempio n. 37
0
			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)
Esempio n. 38
0
			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")
Esempio n. 40
0
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))
Esempio n. 41
0
		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()
	
	
Esempio n. 42
0
	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
Esempio n. 43
0
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()
Esempio n. 44
0
	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)
Esempio n. 45
0
	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)
Esempio n. 46
0
		
	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
Esempio n. 47
0
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))
Esempio n. 48
0
    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)
Esempio n. 49
0
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)
Esempio n. 50
0
    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)
Esempio n. 51
0
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()
Esempio n. 52
0
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()