def makeFirstRefList(self, labelFile, scale=0.00995):
"""
Read in a label.dat file specificed in <labelFile> and convert
it into a starfinder *_rms.lis file. Coordinates in label.dat
are assumed to be in arcseconds and they will be converted to
NIRC2 narrow pixels using <scale>. Sgr A* will be centered at
x=2000, y=2000 in the output list.
labelFile - (string) The name of the label.dat file.
scale - (float) The pixels scale in arcsec/pixel.
"""
labels = starTables.Labels(labelFile=labelFile)
starlist = starTables.StarfinderList(None, hasErrors=True)
# We need to pull out the date of this epoch. Pull this from the
# first image starlist in the mosaic.
firstList = self.dataDir + self.images[0] + '_rms.lis'
tmpList = starTables.StarfinderList(firstList)
date = tmpList.epoch[0]
# Trim label list to only stars with use? != 0
idx = np.where(labels.useToAlign == 1)[0]
labels.take(idx)
# Convert label velocities to arcsec/yr instead of mas/yr
labels.vx /= 1000.0
labels.vy /= 1000.0
labels.vxerr /= 1000.0
labels.vyerr /= 1000.0
starlist.name = labels.name
starlist.mag = labels.mag
starlist.epoch = np.zeros(len(labels.name), dtype=float)
starlist.epoch += date
dt = date - labels.t0
starlist.x = ((labels.x + labels.vx * dt) / -scale) + 2000.0
starlist.y = ((labels.y + labels.vy * dt) / scale) + 2000.0
starlist.xerr = np.sqrt(labels.xerr**2 + (labels.vxerr * dt)**2)
starlist.xerr /= scale
starlist.yerr = np.sqrt(labels.yerr**2 + (labels.vyerr * dt)**2)
starlist.yerr /= scale
starlist.snr = np.ones(len(labels.name))
starlist.corr = np.ones(len(labels.name))
starlist.nframes = np.ones(len(labels.name))
starlist.counts = np.ones(len(labels.name))
outFile = self.lisDir + labelFile.split('/')[-1]
outFile = outFile.replace('.dat', '_rms.lis')
print 'Saving to %s' % outFile
starlist.saveToFile(outFile)
def name_new_stars(self, oldNames):
mosaicRoot = 'mag' + self.epoch +'_'+ self.mosaic +'_'+ self.filter
starlist = self.tableDir + mosaicRoot + '_rms_named_abs_xwest.lis'
labelNewFile = self.tableDir+'/label_new.dat'
labels = starTables.Labels(labelFile=labelNewFile)
list = starTables.StarfinderList(starlist, hasErrors=True)
# Go through the existing named sources and figure out the highest
# star index number.
highestIndex = {}
for ii in range(len(labels.name)):
name = labels.name[ii]
if name.startswith('S') and '-' in name:
parts = name.split('-')
radius = int(parts[0].replace('S', ''))
index = int(parts[1])
if highestIndex.has_key(radius):
if index > highestIndex[radius]:
highestIndex[radius] = index
else:
highestIndex[radius] = index
# Work with the starlist
list.x *= -1.0
list.r = np.hypot(list.x, list.y)
for ii in range(len(oldNames)):
idx = np.where(list.name == oldNames[ii])[0]
rBin = int(math.floor( list.r[idx] ))
highestIndex[rBin] += 1
newName = 'S%d-%d' % (rBin, highestIndex[rBin])
print '%-11s %4.1f %8.4f %8.4f %8.4f %8.4f 0.000 0.000 0.000 0.000 %8.3f 0 %6.3f' % \
(newName, list.mag[idx], list.x[idx], list.y[idx],
list.xerr[idx], list.yerr[idx], list.epoch[idx], list.r[idx])
def convertToAbsolute(self):
"""
Make a sham starlist in arcseconds with +x to the west. This is
for Tuan's data analysis.
"""
mosaicRoot = 'mag' + self.epoch +'_'+ self.mosaic +'_'+ self.filter
starlist = self.tableDir + mosaicRoot + '_rms_named.lis'
lis = starTables.StarfinderList(starlist, hasErrors=True)
labels = starTables.Labels()
# Convert the coordinates to arcseconds
xpix = lis.x
ypix = lis.y
xpixerr = lis.xerr
ypixerr = lis.yerr
# Find 16C in both lists
lis16C = np.where(lis.name == 'irs16C')
lab16C = np.where(labels.name == 'irs16C')
scale = 0.00995
x = (xpix - xpix[lis16C]) * scale * -1.0
x += labels.x[lab16C]
x *= -1.0
y = (ypix - ypix[lis16C]) * scale
y += labels.y[lab16C]
xe = xpixerr * scale
ye = ypixerr * scale
lis.x = x
lis.y = y
lis.xerr = xe
lis.yerr = ye
lis.saveToFile(starlist.replace('.lis', '_abs_xwest.lis'))
shutil.copyfile(self.tableDir + mosaicRoot + '_rms_named_abs_xwest.lis',
self.dataDir + mosaicRoot + '_rms_named_abs_xwest.lis')
def update_labels(labelFile):
# Read in the label.dat file
lab = starTables.Labels(labelFile=labelFile)
# Create a connection to the database
connection = sqlite.connect(dbfile)
# Create a cursor object
cur = connection.cursor()
# Loop through all the stars and insert or replace them
for ss in range(len(lab.name)):
sql = 'insert or replace into stars '
sql += '(name, kp, x, y, xerr, yerr, t0, '
sql += 'vx, vy, vxerr, vyerr, useToAlign) '
sql += 'values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
cur.execute(
sql,
(lab.name[ss], lab.mag[ss], lab.x[ss], lab.y[ss], lab.xerr[ss],
lab.yerr[ss], lab.t0[ss], lab.vx[ss], lab.vy[ss], lab.vxerr[ss],
lab.vyerr[ss], lab.useToAlign[ss]))
connection.commit()
def gcimf_completeness():
"""
Make a completeness curve for every osiris spectroscopic field. Use
the completeness analysis from mag06maylgs1_dp_msc.
"""
# Keep a mapping of which OSIRIS field corresponds to which
# NIRC2 field in the dp_msc.
osiris2nirc2 = {
'GC Central': 'C',
'GC East': 'C',
'GC South': 'C',
'GC Southeast': 'C',
'GC Southwest': 'C',
'GC West': 'C',
'GC Northwest': 'C',
'GC North': 'C',
'GC Northeast': 'C',
'E2-1': 'C_NE',
'E2-2': 'C_SE',
'E2-3': 'C_SE',
'E3-1': 'E',
'E3-2': 'E',
'E3-3': 'E',
'E4-1': 'E',
'E4-2': 'E',
'E4-3': 'E'
}
# Load up the label.dat file and use the coordinates in there
# to astrometrically calibrate each NIRC2 dp_msc field.
label = starTables.Labels()
# Load up the spectroscopic database to get the field-of-view definitions.
dbfile = '/u/jlu/data/gc/database/stars.sqlite'
connection = sqlite.connect(dbfile)
cur = connection.cursor()
cur.execute('select name, x_vertices, y_vertices from fields')
rows = cur.fetchall()
# Completeness Directory
compDir = '/u/jlu/work/gc/dp_msc/2010_09_17/completeness'
# NIRC2 Data directory
nirc2Dir = '/u/ghezgroup/data/gc/06maylgs1/combo'
for rr in range(len(rows)):
fieldName = rows[rr][0]
print 'Working on field %s' % fieldName
xverts = np.array([float(ff) for ff in rows[rr][1].split(',')])
yverts = np.array([float(ff) for ff in rows[rr][2].split(',')])
xyverts = np.column_stack((xverts, yverts))
# Load up the corresponding NIRC2 completeness starlists
nircFieldName = osiris2nirc2[fieldName]
alignDir = '%s/%s/kp/06maylgs1/align/' % \
(compDir, nircFieldName)
cData = starPlant.load_completeness(alignDir)
# Load up information on the coo star for this field
cooFile = '%s/mag06maylgs1_dp_msc_%s_kp.coo' % (nirc2Dir,
nircFieldName)
cooTmp = open(cooFile).readline().split()
cooPix = [float(cooTmp[0]), float(cooTmp[1])]
idx = np.where(label.name == cooStarDict[nircFieldName])[0][0]
cooAsec = [label.x[idx], label.y[idx]]
scale = 0.00995
# Convert the completeness results to absolute coordinates
cData.x_in = ((cData.x_in - cooPix[0]) * scale * -1) + cooAsec[0]
cData.y_in = ((cData.y_in - cooPix[1]) * scale) + cooAsec[1]
cData.x_out = ((cData.x_out - cooPix[0]) * scale * -1) + cooAsec[0]
cData.y_out = ((cData.y_out - cooPix[1]) * scale) + cooAsec[1]
cData.x = ((cData.x - cooPix[0]) * scale * -1) + cooAsec[0]
cData.y = ((cData.y - cooPix[0]) * scale * -1) + cooAsec[0]
# Now trim down to just those pixels that are within this
# OSIRIS field of view
xypoints = np.column_stack((cData.x_in, cData.y_in))
inside = nxutils.points_inside_poly(xypoints, xyverts)
inside = np.where(inside == True)[0]
# Measure the completeness for this OSIRIS field. Also print it
# out into a file.
outRoot = 'completeness_%s' % fieldName.replace(' ', '')
completeness = np.zeros(len(cData.mag), dtype=float)
_comp = open(outRoot + '.dat', 'w')
for mm in range(len(cData.mag)):
# All planted stars in this field
planted = np.where(cData.m_in[inside] == cData.mag[mm])[0]
# All detected stars in this field
detected = np.where(cData.f_out[inside][planted] > 0)[0]
completeness[mm] = float(len(detected)) / float(len(planted))
_comp.write(
'%5.2f %6.3f %3d %3d\n' %
(cData.mag[mm], completeness[mm], len(planted), len(detected)))
py.clf()
py.plot(cData.mag, completeness, 'k.-')
py.xlabel('Kp Magnitude')
py.ylabel('Completeness')
py.title('OSIRIS Field %s, NIRC2 Field %s' %
(fieldName, nircFieldName))
py.ylim(0, 1.1)
py.xlim(9, 20)
py.savefig(outRoot + '.png')
def plot_young_stars():
# Load up the spectroscopic database to get the field-of-view definitions.
dbfile = '/u/jlu/data/gc/database/stars.sqlite'
connection = sqlite.connect(dbfile)
cur = connection.cursor()
cur.execute('select name, x, y, kp from stars where young="T"')
yngRows = cur.fetchall()
cur.execute('select name, x, y, kp from stars where old="T"')
oldRows = cur.fetchall()
cur.execute('select name, x_vertices, y_vertices from fields')
regions = cur.fetchall()
fieldNames = []
xverts = []
yverts = []
for rr in range(len(regions)):
fieldNames.append(regions[rr][0])
xverts.append(np.array([float(ff)
for ff in regions[rr][1].split(',')]))
yverts.append(np.array([float(ff)
for ff in regions[rr][2].split(',')]))
# Load up the 06maylgs1 mosaic image
imageRoot = '/u/jlu/work/gc/imf/gcows/'
imageRoot += 'mag06maylgs1_dp_msc_kp'
img = pyfits.getdata(imageRoot + '.fits')
# Coo star is IRS 16C
coords = open(imageRoot + '.coo').readline().split()
cooPix = [float(coords[0]), float(coords[1])]
# Load up the label.dat file to get the coordinates in arcsec
label = starTables.Labels()
idx = np.where(label.name == 'irs16C')[0]
cooAsec = [label.x[idx[0]], label.y[idx[0]]]
scale = 0.00995
xmin = ((0 - cooPix[0]) * scale * -1.0) + cooAsec[0]
xmax = ((img.shape[1] - cooPix[0]) * scale * -1.0) + cooAsec[0]
ymin = ((0 - cooPix[1]) * scale) + cooAsec[1]
ymax = ((img.shape[0] - cooPix[1]) * scale) + cooAsec[1]
extent = [xmin, xmax, ymin, ymax]
# Loop through the stars and make arrays
numYng = len(yngRows)
numOld = len(oldRows)
yngName = np.zeros(numYng, dtype='S13')
yngX = np.zeros(numYng, dtype=float)
yngY = np.zeros(numYng, dtype=float)
yngKp = np.zeros(numYng, dtype=float)
oldName = np.zeros(numOld, dtype='S13')
oldX = np.zeros(numOld, dtype=float)
oldY = np.zeros(numOld, dtype=float)
oldKp = np.zeros(numOld, dtype=float)
for yy in range(len(yngRows)):
yngName[yy] = yngRows[yy][0]
yngX[yy] = yngRows[yy][1]
yngY[yy] = yngRows[yy][2]
yngKp[yy] = yngRows[yy][3]
for oo in range(len(oldRows)):
oldName[oo] = oldRows[oo][0]
oldX[oo] = oldRows[oo][1]
oldY[oo] = oldRows[oo][2]
oldKp[oo] = oldRows[oo][3]
print extent
py.clf()
py.imshow(img, extent=extent, cmap=py.cm.gray_r, vmin=0, vmax=10000)
py.plot(yngX,
yngY,
'bo',
markerfacecolor='none',
markersize=10,
markeredgecolor='blue',
markeredgewidth=2)
py.plot(oldX,
oldY,
'ro',
markerfacecolor='none',
markersize=10,
markeredgecolor='red',
markeredgewidth=2)
for yy in range(numYng):
txt = '%s, Kp=%5.2f' % (yngName[yy], yngKp[yy])
# txt = '%5.2f' % (yngKp[yy])
py.text(yngX[yy], yngY[yy], txt, color='blue')
py.axis('tight')
py.axis('equal')
for ff in range(len(fieldNames)):
py.plot(np.append(xverts[ff], xverts[ff][0]),
np.append(yverts[ff], yverts[ff][0]),
color='black')
def plotStarfinderList(
starList,
hasErrors=True,
magCut=18,
cooStarList='16C',
cooStarLabels='irs16C',
scaleList=0.00995,
scaleImg=0.00995,
image='/u/ghezgroup/data/gc/06maylgs1/combo/mag06maylgs1_dp_msc_kp.fits'
):
"""
Plot the specified image and overlay the photo_calib.dat sources on top.
Coordinates are converted from pixels to arcsec using the coo star and
assuming that the angle of the image is 0.
This code assumes coordinates are NIRC2 narrow pixels coordaintes. You can modify this by
changing the scale. But +x must be to the west in the starlist.
"""
# Load up the photometric calibraters table.
lis = starTables.StarfinderList(starList, hasErrors=hasErrors)
labels = starTables.Labels()
# Find the coo star in the starlist and in the labels
ii1 = np.where(lis.name == cooStarList)[0]
ii2 = np.where(labels.name == cooStarLabels)[0]
dt = lis.epoch[0] - labels.t0
labels.x += (labels.vx / 10**3) * dt
labels.y += (labels.vy / 10**3) * dt
# Convert the pixels in the starlist into arcsec
x = ((lis.x - lis.x[ii1]) * -scaleList) + labels.x[ii2]
y = ((lis.y - lis.y[ii1]) * scaleList) + labels.y[ii2]
im = pyfits.getdata(image)
imgsize = (im.shape)[0]
# pixel position (0,0) is at upper left
xpix = np.arange(0, im.shape[0], dtype=float)
ypix = np.arange(0, im.shape[1], dtype=float)
# Read in the image coo file
# Coo star pixel coordinates
_coo = open(image.replace('.fits', '.coo'), 'r')
coordsTmp = _coo.readline().split()
coords = [float(coo) for coo in coordsTmp]
print 'Coordinates for %s:' % cooStarLabels
print ' [%10.4f, %10.4f] pixels' % (coords[0], coords[1])
print ' [%10.4f, %10.4f] arcsec' % (labels.x[ii2], labels.y[ii2])
sgrax = coords[0] - (labels.x[ii2] / -scaleImg)
sgray = coords[1] - (labels.y[ii2] / scaleImg)
sgra = [sgrax, sgray]
# Image coordinates (in arcsec)
xim = (xpix - sgra[0]) * -scaleImg
yim = (ypix - sgra[1]) * scaleImg
py.clf()
py.close(2)
py.figure(2, figsize=(6, 4.5))
py.grid(True)
py.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95)
py.imshow(np.log10(im),
extent=[xim[0], xim[-1], yim[0], yim[-1]],
aspect='equal',
vmin=1.9,
vmax=6.0,
cmap=py.cm.gray)
py.xlabel('X Offset from Sgr A* (arcsec)')
py.ylabel('Y Offset from Sgr A* (arcsec)')
py.title('UCLA/Keck Galactic Center Group', fontsize=20, fontweight='bold')
thePlot = py.gca()
py.axis([15, -15, -15, 15])
idx = (np.where((lis.mag < magCut) & (x > xim.min()) & (x < xim.max())
& (y > yim.min()) & (y < yim.max())))[0]
py.plot(x[idx], y[idx], 'r+', color='orange')
for ii in idx:
py.text(x[ii], y[ii], lis.name[ii], color='orange', fontsize=10)
def plotLabelAndAlign(alignRoot,
polyRoot,
magCut=25,
labelFile='label.dat',
showStars=True):
label = starTables.Labels(labelFile)
label.take(np.where(label.mag < magCut)[0])
t = 2005.580
x_lab = label.x + label.vx * (t - label.t0) / 10**3
y_lab = label.y + label.vy * (t - label.t0) / 10**3
n_lab = label.ourName
use = label.useToAlign
# Now read in the align stuff
s = starset.StarSet(alignRoot)
s.loadPolyfit(polyRoot, accel=0)
mag = s.getArray('mag')
idx = np.where(mag < magCut)[0]
s.stars = [s.stars[ii] for ii in idx]
n_aln = np.array(s.getArray('name'))
mag = s.getArray('mag')
x0 = s.getArray('fitXv.p') * -1.0
y0 = s.getArray('fitYv.p')
x0err = s.getArray('fitXv.perr')
y0err = s.getArray('fitYv.perr')
vx = s.getArray('fitXv.v') * -1.0
vy = s.getArray('fitYv.v')
vxerr = s.getArray('fitXv.verr')
vyerr = s.getArray('fitYv.verr')
t0x = s.getArray('fitXv.t0')
t0y = s.getArray('fitYv.t0')
r = np.hypot(x0, y0)
x_aln = x0 + vx * (t - t0x)
y_aln = y0 + vy * (t - t0y)
# Fix x0err, y0err to some minimum value
idx = np.where(x0err < 0.0001)[0]
x0err[idx] = 0.0001
idx = np.where(y0err < 0.0001)[0]
y0err[idx] = 0.0001
# First lets update the 16 sources since they are used
# to align label.dat to the reference epoch (crude I know)
names16 = [
'irs16C', 'irs16NW', 'irs16CC', 'irs16NE', 'irs16SW', 'irs16SW-E',
'irs33N', 'irs33E'
]
for nn in range(len(names16)):
idx = np.where(n_aln == names16[nn])[0]
for rr in idx:
print '%-11s %4.1f %6.3f %6.3f %7.4f %7.4f %8.3f %8.3f %7.3f %7.3f %8.3f 1 %5.3f' % \
(n_aln[rr], mag[rr], x0[rr], y0[rr], x0err[rr],
y0err[rr], vx[rr]*10**3, vy[rr]*10**3,
vxerr[rr]*10**3, vyerr[rr]*10**3, t0x[rr], r[rr])
# Image
imageFile = '/u/ghezgroup/data/gc/'
imageFile += '06maylgs1/combo/mag06maylgs1_dp_msc_kp.fits'
im = pyfits.getdata(imageFile)
imgsize = (im.shape)[0]
# pixel position (0,0) is at upper left
xpix = np.arange(0, im.shape[0], dtype=float)
ypix = np.arange(0, im.shape[1], dtype=float)
sgra = [1422.6, 1543.8]
scale_jpg = 0.00994
xim = (xpix - sgra[0]) * scale_jpg * -1.0
yim = (ypix - sgra[1]) * scale_jpg
# Lets also make some coordinates for compass rose and scale bar
xrose = np.array([-15.5, -15.5])
yrose = np.array([15.5, 15.5])
xroseLen = np.array([20.0, 0.0])
yroseLen = np.array([0.0, 20.0])
py.clf()
py.close(1)
py.close(2)
def drawImage(xlo, xhi, ylo, yhi):
py.figure(2, figsize=(9, 9))
py.grid(True)
py.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95)
py.imshow(np.log10(im),
extent=[xim[0], xim[-1], yim[0], yim[-1]],
aspect='equal',
vmin=2.0,
vmax=4.0,
cmap=py.cm.gray)
py.xlabel('X Offset from Sgr A* (arcsec)')
py.ylabel('Y Offset from Sgr A* (arcsec)')
py.title('UCLA/Keck Galactic Center Group',
fontsize=20,
fontweight='bold')
thePlot = py.gca()
# Plot label.dat points
py.plot(x_lab, y_lab, 'rs')
for ii in range(len(x_lab)):
py.text(x_lab[ii], y_lab[ii], n_lab[ii], color='red', fontsize=10)
# Plot align points
py.plot(x_aln, y_aln, 'bo')
for ii in range(len(x_aln)):
py.text(x_aln[ii], y_aln[ii], n_aln[ii], color='blue', fontsize=10)
py.axis([xlo, xhi, ylo, yhi])
# We can do some matching here to help us out.
drawImage(15, -15, -15, 15)
if showStars:
fmt = '%-11s %4.1f %9.5f %9.5f %8.5f %8.5f %8.3f %8.3f %7.3f %7.3f %8.3f %1d %5.3f\n'
gcutil.rmall(['label_updated.dat'])
out = open('label_updated.dat', 'w')
out.write(
'#Name K x y xerr yerr vx vy vxerr vyerr t0 use? r2d\n'
)
out.write(
'#() (mag) (asec) (asec) (asec) (asec) (mas/yr) (mas/yr) (mas/yr) (mas/yr) (year) () (asec)\n'
)
foo = raw_input('Continue?')
for ss in range(len(x_lab)):
update = 0
idx = np.where(n_aln == n_lab[ss])[0]
# The rest of the code allows us to find stars that were not matched
# between the old label and new absolute alignment.
# This will write out the new info from absolute alignment to a new
# label_updated.dat file for just those stars that weren't matched properly,
# but still need to run updateLabelInfoWithAbsRefs() to update the info
# for stars that were matched.
if len(idx) == 0:
dr = np.hypot(x_aln - x_lab[ss], y_aln - y_lab[ss])
rdx = np.where(dr < 0.2)[0]
if len(rdx) > 0:
xlo = x_lab[ss] + 0.2
xhi = x_lab[ss] - 0.2
ylo = y_lab[ss] - 0.2
yhi = y_lab[ss] + 0.2
py.axis([xlo, xhi, ylo, yhi])
print 'Did not find a match for %s (K=%4.1f x=%7.3f y = %7.3f):' % \
(n_lab[ss], label.mag[ss], x_lab[ss], y_lab[ss])
for rr in rdx:
print fmt % \
(n_aln[rr], mag[rr], x0[rr], y0[rr], x0err[rr],
y0err[rr], vx[rr]*10**3, vy[rr]*10**3,
vxerr[rr]*10**3, vyerr[rr]*10**3, t0x[rr], use[ss], r[rr])
# if the starname in align has the same ending as the name in
# label.dat, it's likely the same star (e.g. '1S9-87' and 'S9-87';
# Note that this is the naming used in mosaicked star list analysis)
if n_aln[rr].endswith(n_lab[ss]):
# do a check that these stars have similar magnitudes
if np.abs(label.mag[ss] - mag[rr]) <= 0.5:
update = 1
# replace the whole line in label_updated.dat
out.write(fmt % \
(n_lab[ss], mag[rr], x0[rr], y0[rr], x0err[rr],
y0err[rr], vx[rr]*10**3, vy[rr]*10**3,
vxerr[rr]*10**3, vyerr[rr]*10**3, t0x[rr], use[ss], r[rr]))
continue
else:
foo = raw_input(
'Similar names, but magnitudes are off. Check star %s manually and decide whether or not to replace it in label_updated.dat when this program completes. Hit enter to continue.'
% n_aln[rr])
# Or the star just wasn't matched with any star in the old label.dat file
# and was given an arbitrary name
elif (('star' in n_aln[rr]) | ('ep' in n_aln[rr])):
print 'Manually check and update this star if needed:'
print 'Name in label: %s' % n_lab[ss]
print 'Name in new alignment: %s' % n_aln[rr]
if len(rdx) > 1:
print 'CAUTION: There are other nearby stars, including:'
for ii in range(len(rdx)):
print n_aln[rdx[ii]]
update = raw_input(
'Update with %s velocity? (enter 1 for yes; 0 for no) '
% n_aln[rr])
update = int(update)
if update == 1:
out.write(fmt % \
(n_lab[ss], mag[rr], x0[rr], y0[rr], x0err[rr],
y0err[rr], vx[rr]*10**3, vy[rr]*10**3,
vxerr[rr]*10**3, vyerr[rr]*10**3, t0x[rr], use[ss], r[rr]))
# check magnitude offset
#if np.abs(label.mag[ss] - mag[rr]) <= 0.5:
# update = 1
# # replace the whole line in label_updated.dat
# out.write(fmt % \
# (n_lab[ss], mag[rr], x0[rr], y0[rr], x0err[rr],
# y0err[rr], vx[rr]*10**3, vy[rr]*10**3,
# vxerr[rr]*10**3, vyerr[rr]*10**3, t0x[rr], 1, r[rr]))
if update == 0:
# just re-write what was in label.dat, and later run
# updateLabelInfoWithAbsRefs() to update matched stars with the new
# absolute alignment
out.write(fmt % \
(label.ourName[ss], label.mag[ss], label.x[ss], label.y[ss],
label.xerr[ss], label.yerr[ss], label.vx[ss], label.vy[ss],
label.vxerr[ss], label.vyerr[ss], label.t0[ss], use[ss],
label.r[ss]))
out.close()
def arches_figure():
"""
Plot a 3 panel figure showing seeing-limited, HST, and AO data on the
Arches cluster to illustrate the power of AO.
"""
# ----------
# NIRC2
# ----------
hroot = 'mag06maylgs2_arch_f1_h'
kroot = 'mag06maylgs2_arch_f1_kp'
lroot = 'mag06maylgs2_arch_f1_lp'
cooStar = 'f1_psf0'
scaleMinH = 1000
scaleMinK = 800
scaleMinL = 600
scaleMaxH = 4500
scaleMaxK = 8000
scaleMaxL = 10000
img = np.zeros((1500, 1500, 3), dtype=float)
origin = np.array([750.0, 750.0])
labelFile = '/u/ghezgroup/data/gc/source_list/label_arch.dat'
labels = starTables.Labels(labelFile=labelFile)
dataDir = '/u/ghezgroup/data/gc/06maylgs2/combo/'
# Load up the images
h = pyfits.getdata(dataDir + hroot + '.fits')
k = pyfits.getdata(dataDir + kroot + '.fits')
l = pyfits.getdata(dataDir + lroot + '.fits')
# Make the arrays into the largest size.
h_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
k_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
l_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
h_new[0:h.shape[0], 0:h.shape[1]] = h
k_new[0:k.shape[0], 0:k.shape[1]] = k
l_new[0:l.shape[0], 0:l.shape[1]] = l
# Load up the coo stars
tmpH = open(dataDir + hroot + '.coo').readline().split()
cooH = np.array([float(tmpH[0]), float(tmpH[1])])
tmpK = open(dataDir + kroot + '.coo').readline().split()
cooK = np.array([float(tmpK[0]), float(tmpK[1])])
tmpL = open(dataDir + lroot + '.coo').readline().split()
cooL = np.array([float(tmpL[0]), float(tmpL[1])])
# Get the coordinates of each coo star in arcsec.
idxH = np.where(labels.name == cooStar)[0][0]
idxK = np.where(labels.name == cooStar)[0][0]
idxL = np.where(labels.name == cooStar)[0][0]
asecH = np.array([labels.x[idxH], labels.y[idxH]])
asecK = np.array([labels.x[idxK], labels.y[idxK]])
asecL = np.array([labels.x[idxL], labels.y[idxL]])
scale = np.array([-0.00995, 0.00995])
# Now figure out the necessary shifts
originH = cooH - asecH / scale
originK = cooK - asecK / scale
originL = cooL - asecL / scale
# Shift the J and H images to be lined up with K-band
shiftL = origin - originL
shiftK = origin - originK
shiftH = origin - originH
l = interp.shift(l_new, shiftL[::-1])
k = interp.shift(k_new, shiftK[::-1])
h = interp.shift(h_new, shiftH[::-1])
print shiftH
print shiftL
xx, yy = np.meshgrid(np.arange(img.shape[0]), np.arange(img.shape[1]))
idx = np.where((h >= 1) & (k >= 1) & (l >= 1))
# Trim off the bottom 10 rows where there is data
ymin = yy[idx[0], idx[1]].min()
ydx = np.where(yy[idx[0], idx[1]] > (ymin + 10))[0]
idx = (idx[0][ydx], idx[1][ydx])
# gcutil.rmall(['arches_f1_h.fits', 'arches_f1_kp.fits', 'arches_f1_lp.fits'])
# pyfits.writeto('arches_f1_h.fits', h)
# pyfits.writeto('arches_f1_kp.fits', k)
# pyfits.writeto('arches_f1_lp.fits', l)
img[idx[0], idx[1], 0] = img_scale.sqrt(l[idx[0], idx[1]],
scale_min=scaleMinL,
scale_max=scaleMaxL)
img[idx[0], idx[1], 1] = img_scale.sqrt(k[idx[0], idx[1]],
scale_min=scaleMinK,
scale_max=scaleMaxK)
img[idx[0], idx[1], 2] = img_scale.sqrt(h[idx[0], idx[1]],
scale_min=scaleMinH,
scale_max=scaleMaxH)
# Define the axes
xaxis = np.arange(-0.5, img.shape[1] + 0.5, 1)
xaxis = ((xaxis - origin[0]) * scale[0])
yaxis = np.arange(-0.5, img.shape[0] + 0.5, 1)
yaxis = ((yaxis - origin[1]) * scale[1])
extent = [xaxis[0], xaxis[-1], yaxis[0], yaxis[-1]]
img_nirc2 = img
ext_nirc2 = extent
# ----------
# UKIDSS
# ----------
scaleMinJ = 20
scaleMinH = 400
scaleMinK = 1000
scaleMaxJ = 5000
scaleMaxH = 35000
scaleMaxK = 90000
dataDir = '/u/jlu/data/arches/ukidss/'
# Load up the images
j = pyfits.getdata(dataDir + 'ukidss_arches_j.fits')
h = pyfits.getdata(dataDir + 'ukidss_arches_h.fits')
k = pyfits.getdata(dataDir + 'ukidss_arches_k.fits')
img = np.zeros((j.shape[0], j.shape[1], 3), dtype=float)
origin = [173, 198]
scale = [-0.2, 0.2]
xx, yy = np.meshgrid(np.arange(img.shape[0]), np.arange(img.shape[1]))
img[:, :, 0] = img_scale.sqrt(k, scale_min=scaleMinK, scale_max=scaleMaxK)
img[:, :, 1] = img_scale.sqrt(h, scale_min=scaleMinH, scale_max=scaleMaxH)
img[:, :, 2] = img_scale.sqrt(j, scale_min=scaleMinJ, scale_max=scaleMaxJ)
# Define the axes
xaxis = np.arange(-0.5, img.shape[1] + 0.5, 1)
xaxis = ((xaxis - origin[0]) * scale[0])
yaxis = np.arange(-0.5, img.shape[0] + 0.5, 1)
yaxis = ((yaxis - origin[1]) * scale[1])
extent = [xaxis[0], xaxis[-1], yaxis[0], yaxis[-1]]
img_ukidss = img
ext_ukidss = extent
py.figure(2, figsize=(6, 12))
py.clf()
py.subplots_adjust(bottom=0.05, top=0.95, hspace=0.25)
py.subplot(2, 1, 1)
py.imshow(img_ukidss, extent=ext_ukidss)
py.axis('equal')
py.axis([4.5, -6.5, -6.5, 4.5])
py.title('UKIDSS JHK')
py.xlabel('R.A. Offset (arcsec)')
py.ylabel('Dec. Offset (arcsec)')
py.subplot(2, 1, 2)
py.imshow(img_nirc2, extent=ext_nirc2)
py.axis('equal')
py.axis([4.5, -6.5, -6.5, 4.5])
py.title("Keck AO HK'L'")
py.xlabel('R.A. Offset (arcsec)')
py.ylabel('Dec. Offset (arcsec)')
py.savefig('arches_see_vs_ao.png')
def mosaic3color():
"""
Make a 3 color mosaic of our NIRC2 data on W51.
"""
hepochs = ['09jun26', '09jun26', '09jun26', '09jun26']
kepochs = ['09jun10', '09jun10', '09jun10', '09jun26']
lepochs = ['09jun26', '09jun26', '09jun26', '09jun26']
cooStarsH = ['f1_psf0', 'f2_psf0', 'f3_psf0', 'f4_psf0']
cooStarsK = ['f1_psf0', 'f2_psf0', 'f3_psf0', 'f4_psf0']
cooStarsL = ['f1_psf1', 'f2_psf0', 'f3_psf2', 'f4_psf1']
cooStarsH = ['E4-1', 'E8-1', 'N5-1', 'W6-2']
cooStarsK = ['E4-1', 'E8-1', 'N5-1', 'W6-2']
cooStarsL = ['S0-1', 'E8-1', 'W7-1', 'W9-1']
scaleMinH = [0, 0, 0, 0]
scaleMinK = [0, 0, 0, 0]
scaleMinL = [1000, 1100, 1200, 1250]
scaleMaxH = [6000, 6000, 5000, 6000]
scaleMaxK = [5500, 5500, 5500, 4500]
# scaleMaxL = [1600, 1300, 1400, 1600]
scaleMaxL = [2000, 2000, 2000, 2000]
img = np.zeros((2400, 2400, 3), dtype=float)
origin = np.array([1200.0, 1200.0])
labelFile = '/u/jlu/data/w51/source_list/w51a_label.dat'
labels = starTables.Labels(labelFile=labelFile)
dataRoot = '/u/jlu/data/w51/'
py.clf()
foo = range(len(hepochs))
for ii in foo[::-1]:
# for ii in range(1):
rootH = '%s/%s/combo/mag%s_w51a_f%d_h' % \
(dataRoot, hepochs[ii], hepochs[ii], ii+1)
rootK = '%s/%s/combo/mag%s_w51a_f%d_kp' % \
(dataRoot, kepochs[ii], kepochs[ii], ii+1)
rootL = '%s/%s/combo/mag%s_w51a_f%d_lp' % \
(dataRoot, lepochs[ii], lepochs[ii], ii+1)
# Load up the images
h = pyfits.getdata(rootH + '.fits')
k = pyfits.getdata(rootK + '.fits')
l = pyfits.getdata(rootL + '.fits')
# Make the arrays into the largest size.
h_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
k_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
l_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
h_new[0:h.shape[0], 0:h.shape[1]] = h
k_new[0:k.shape[0], 0:k.shape[1]] = k
l_new[0:l.shape[0], 0:l.shape[1]] = l
# Load up the coo stars
tmpH = open(rootH + '.coo').readline().split()
cooH = np.array([float(tmpH[0]), float(tmpH[1])])
tmpK = open(rootK + '.coo').readline().split()
cooK = np.array([float(tmpK[0]), float(tmpK[1])])
tmpL = open(rootL + '.coo').readline().split()
cooL = np.array([float(tmpL[0]), float(tmpL[1])])
# Get the coordinates of each coo star in arcsec.
idxH = np.where(labels.name == cooStarsH[ii])[0][0]
idxK = np.where(labels.name == cooStarsK[ii])[0][0]
idxL = np.where(labels.name == cooStarsL[ii])[0][0]
asecH = np.array([labels.x[idxH], labels.y[idxH]])
asecK = np.array([labels.x[idxK], labels.y[idxK]])
asecL = np.array([labels.x[idxL], labels.y[idxL]])
scale = np.array([-0.00995, 0.00995])
# Now figure out the necessary shifts
originH = cooH - asecH / scale
originK = cooK - asecK / scale
originL = cooL - asecL / scale
# Shift the J and H images to be lined up with K-band
shiftL = origin - originL
shiftK = origin - originK
shiftH = origin - originH
l = interp.shift(l_new, shiftL[::-1])
k = interp.shift(k_new, shiftK[::-1])
h = interp.shift(h_new, shiftH[::-1])
print shiftH
print shiftL
xx, yy = np.meshgrid(np.arange(img.shape[0]), np.arange(img.shape[1]))
idx = np.where((h >= 1) & (k >= 1) & (l >= 1))
# Trim off the bottom 10 rows where there is data
ymin = yy[idx[0], idx[1]].min()
ydx = np.where(yy[idx[0], idx[1]] > (ymin + 10))[0]
idx = (idx[0][ydx], idx[1][ydx])
img[idx[0], idx[1], 0] = img_scale.sqrt(l[idx[0], idx[1]],
scale_min=scaleMinL[ii],
scale_max=scaleMaxL[ii])
img[idx[0], idx[1], 1] = img_scale.sqrt(k[idx[0], idx[1]],
scale_min=scaleMinK[ii],
scale_max=scaleMaxK[ii])
img[idx[0], idx[1], 2] = img_scale.sqrt(h[idx[0], idx[1]],
scale_min=scaleMinH[ii],
scale_max=scaleMaxH[ii])
# Defin the axes
xaxis = np.arange(-0.5, img.shape[1] + 0.5, 1)
xaxis = ((xaxis - origin[0]) * scale[0])
yaxis = np.arange(-0.5, img.shape[0] + 0.5, 1)
yaxis = ((yaxis - origin[1]) * scale[1])
extent = [xaxis[0], xaxis[-1], yaxis[0], yaxis[-1]]
py.imshow(img, extent=extent)
py.axis('equal')
foo = raw_input('Continue?')
py.axis([7, -7, -7, 7])
py.savefig('/u/jlu/work/w51/maps/w51a_3color.png')
def plot_wide_labeled(labels='/u/jlu/data/w51/source_list/w51a_label.dat',
markCoordRefStars=False):
lab = starTables.Labels(labelFile=labels)
t = 2009.580
xarc = lab.x + lab.vx * (t - lab.t0) / 10**3
yarc = lab.y + lab.vy * (t - lab.t0) / 10**3
vxarc = lab.vx
vyarc = lab.vy
angle = math.radians(0.0)
cosa = math.cos(angle)
sina = math.sin(angle)
x = xarc * cosa + yarc * sina
y = -xarc * sina + yarc * cosa
vx = vxarc * cosa + vyarc * sina
vy = vxarc * sina - vyarc * cosa
r = np.hypot(x, y)
v = np.hypot(vx, vy)
# Lets also make some coordinates for compass rose and scale bar
xrose = np.array([-15.5, -15.5])
yrose = np.array([15.5, 15.5])
xroseLen = np.array([20.0, 0.0])
yroseLen = np.array([0.0, 20.0])
xr = xrose
yr = yrose
xrlen = xroseLen * cosa + yroseLen * sina
yrlen = xroseLen * sina - yroseLen * cosa
# Image
im = pyfits.getdata(
'/u/jlu/data/w51/09jun26/combo/mag09jun26_w51a_wide_h.fits')
imgsize = (im.shape)[0]
# pixel position (0,0) is at upper left
xpix = np.arange(0, im.shape[0], dtype=float)
ypix = np.arange(0, im.shape[1], dtype=float)
origin = [607.0, 749.0]
scale_jpg = 0.04
xim = (xpix - origin[0]) * scale_jpg * -1.0
yim = (ypix - origin[1]) * scale_jpg
py.clf()
py.grid(True)
py.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95)
py.imshow(np.log10(im),
extent=[xim[0], xim[-1], yim[0], yim[-1]],
aspect='equal',
vmin=0.5,
vmax=5,
cmap=py.cm.gray)
py.xlabel('X Offset (arcsec)')
py.ylabel('Y Offset (arcsec)')
py.title('J. R. Lu', fontsize=20, fontweight='bold')
thePlot = py.gca()
idx = (
np.where( #(mag < 18) &
(x > xim.min()) & (x < xim.max()) & (y > yim.min()) &
(y < yim.max())))[0]
py.plot(x[idx],
y[idx],
'ro',
color='orange',
markerfacecolor='None',
markeredgecolor='orange')
if markCoordRefStars:
mdx = (np.where((x > xim.min()) & (x < xim.max()) & (y > yim.min())
& (y < yim.max()) & (lab.useToAlign != '0')))[0]
py.plot(x[mdx],
y[mdx],
'ro',
color='cyan',
markerfacecolor='None',
markeredgecolor='green')
for ii in idx:
if markCoordRefStars and ii in mdx:
color = 'cyan'
else:
color = 'orange'
py.text(x[ii], y[ii], lab.name[ii], color=color, fontsize=10)
py.axis([15, -15, -15, 15])
py.savefig('w51a_wide_labeled.png', dpi=300)
def mosaic_kp():
"""
Make a mosaic of our NIRC2 data on W51, one per filter.
"""
hepochs = ['09jun26', '09jun26', '09jun26', '09jun26']
kepochs = ['09jun10', '09jun10', '09jun10', '09jun26']
lepochs = ['09jun26', '09jun26', '09jun26', '09jun26']
cooStarsH = ['f1_psf0', 'f2_psf0', 'f3_psf0', 'f4_psf0']
cooStarsK = ['f1_psf0', 'f2_psf0', 'f3_psf0', 'f4_psf0']
cooStarsL = ['f1_psf1', 'f2_psf0', 'f3_psf2', 'f4_psf1']
cooStarsH = ['E4-1', 'E8-1', 'N5-1', 'W6-2']
cooStarsK = ['E4-1', 'E8-1', 'N5-1', 'W6-2']
cooStarsL = ['S0-1', 'E8-1', 'W7-1', 'W9-1']
scaleMinH = [0, 0, 0, 0]
scaleMinK = [0, 0, 0, 0]
scaleMinL = [1000, 1100, 1200, 1250]
scaleMaxH = [6000, 6000, 5000, 6000]
scaleMaxK = [6500, 6500, 6500, 5500]
scaleMaxL = [1600, 1300, 1400, 1600]
img = np.zeros((2400, 2400, 3), dtype=float)
imgH = np.zeros((2400, 2400), dtype=float)
imgK = np.zeros((2400, 2400), dtype=float)
imgL = np.zeros((2400, 2400), dtype=float)
origin = np.array([1200.0, 1200.0])
labelFile = '/u/jlu/data/w51/source_list/w51a_label.dat'
labels = starTables.Labels(labelFile=labelFile)
dataRoot = '/u/jlu/data/w51/'
py.clf()
foo = range(len(hepochs))
for ii in foo[::-1]:
# for ii in range(1):
rootH = '%s/%s/combo/mag%s_w51a_f%d_h' % \
(dataRoot, hepochs[ii], hepochs[ii], ii+1)
rootK = '%s/%s/combo/mag%s_w51a_f%d_kp' % \
(dataRoot, kepochs[ii], kepochs[ii], ii+1)
rootL = '%s/%s/combo/mag%s_w51a_f%d_lp' % \
(dataRoot, lepochs[ii], lepochs[ii], ii+1)
# Load up the images
h, hhdr = pyfits.getdata(rootH + '.fits', header=True)
k, khdr = pyfits.getdata(rootK + '.fits', header=True)
l, lhdr = pyfits.getdata(rootL + '.fits', header=True)
hint = hhdr['ITIME'] * hhdr['COADDS']
kint = khdr['ITIME'] * khdr['COADDS']
lint = lhdr['ITIME'] * lhdr['COADDS']
# Make the arrays into the largest size.
h_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
k_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
l_new = np.zeros((img.shape[0], img.shape[1]), dtype=float)
h_new[0:h.shape[0], 0:h.shape[1]] = h
k_new[0:k.shape[0], 0:k.shape[1]] = k
l_new[0:l.shape[0], 0:l.shape[1]] = l
# Load up the coo stars
tmpH = open(rootH + '.coo').readline().split()
cooH = np.array([float(tmpH[0]), float(tmpH[1])])
tmpK = open(rootK + '.coo').readline().split()
cooK = np.array([float(tmpK[0]), float(tmpK[1])])
tmpL = open(rootL + '.coo').readline().split()
cooL = np.array([float(tmpL[0]), float(tmpL[1])])
# Get the coordinates of each coo star in arcsec.
idxH = np.where(labels.name == cooStarsH[ii])[0][0]
idxK = np.where(labels.name == cooStarsK[ii])[0][0]
idxL = np.where(labels.name == cooStarsL[ii])[0][0]
asecH = np.array([labels.x[idxH], labels.y[idxH]])
asecK = np.array([labels.x[idxK], labels.y[idxK]])
asecL = np.array([labels.x[idxL], labels.y[idxL]])
scale = np.array([-0.00995, 0.00995])
# Now figure out the necessary shifts
originH = cooH - asecH / scale
originK = cooK - asecK / scale
originL = cooL - asecL / scale
# Shift the J and H images to be lined up with K-band
shiftL = origin - originL
shiftK = origin - originK
shiftH = origin - originH
l = interp.shift(l_new, shiftL[::-1])
k = interp.shift(k_new, shiftK[::-1])
h = interp.shift(h_new, shiftH[::-1])
print shiftH
print shiftL
xx, yy = np.meshgrid(np.arange(img.shape[0]), np.arange(img.shape[1]))
idx = np.where((h >= 1) & (k >= 1) & (l >= 1))
# Trim off the bottom 10 rows where there is data
ymin = yy[idx[0], idx[1]].min()
ydx = np.where(yy[idx[0], idx[1]] > (ymin + 10))[0]
idx = (idx[0][ydx], idx[1][ydx])
img[idx[0], idx[1], 0] = img_scale.log(l[idx[0], idx[1]],
scale_min=scaleMinL[ii],
scale_max=scaleMaxL[ii])
img[idx[0], idx[1], 1] = img_scale.log(k[idx[0], idx[1]],
scale_min=scaleMinK[ii],
scale_max=scaleMaxK[ii])
img[idx[0], idx[1], 2] = img_scale.log(h[idx[0], idx[1]],
scale_min=scaleMinH[ii],
scale_max=scaleMaxH[ii])
imgH[idx[0], idx[1]] = h[idx[0], idx[1]] / hint
imgK[idx[0], idx[1]] = k[idx[0], idx[1]] / kint
imgL[idx[0], idx[1]] = l[idx[0], idx[1]] / lint
# Fix scaling of first image.
if ii == 0:
imgK[idx[0], idx[1]] -= 0.4
# Save on memory
l = None
k = None
h = None
l_new = None
k_new = None
h_new = None
# Define the axes
xaxis = np.arange(-0.5, img.shape[1] + 0.5, 1)
xaxis = ((xaxis - origin[0]) * scale[0])
yaxis = np.arange(-0.5, img.shape[0] + 0.5, 1)
yaxis = ((yaxis - origin[1]) * scale[1])
extent = [xaxis[0], xaxis[-1], yaxis[0], yaxis[-1]]
# py.figure(1)
# py.imshow(img[:,:,0], extent=extent, cmap=py.cm.gray)
# py.axis('equal')
py.figure(2)
py.imshow(img[:, :, 1], extent=extent, cmap=py.cm.gray)
py.axis('equal')
# py.figure(3)
# py.imshow(img[:,:,2], extent=extent, cmap=py.cm.gray)
# py.axis('equal')
foo = raw_input('Continue?')
gcutil.rmall(
['w51a_h_mosaic.fits', 'w51a_k_mosaic.fits', 'w51a_l_mosaic.fits'])
pyfits.writeto('w51a_h_mosaic.fits', imgH)
pyfits.writeto('w51a_k_mosaic.fits', imgK)
pyfits.writeto('w51a_l_mosaic.fits', imgL)
