def build_targets(field, path="./"):
"""Top-level program to build target info
Parameters:
-----------
field: tuple
(Name, ra, dec)
"""
# MMT
mmt_masks, mmt_obs, mmt_targs = mmt_targets(field)
# DEIMOS
deimos_sex, deimos_masks, deimos_obs, deimos_targs = deimos_targets(field)
# COLLATE
all_masks = deimos_masks + mmt_masks
all_obs = deimos_obs + mmt_obs
all_sex = vstack([deimos_sex, mmt_targs], join_type="inner") # Use vstack when needed
# Generate Target table
targ_file = xcasbahu.get_filename(field, "TARGETS")
cut_sex = all_sex[["TARG_RA", "TARG_DEC", "EPOCH", "TARG_ID", "TARG_MAG", "TARG_IMG", "INSTR", "MASK_NAME"]]
# cut_sex.write(targ_file,overwrite=True)
cut_sex.write(targ_file, format="ascii.fixed_width", delimiter="|")
print("Wrote file {:s}".format(targ_file))
# Generate MULTI_OBJ file
multi_file = xcasbahu.get_filename(field, "MULTI_OBJ")
tab_names = (
"INSTR",
"MASK_NAME",
"MASK_RA",
"MASK_DEC",
"MASK_EPOCH",
"MASK_PA",
"DATE_OBS",
"DISPERSER",
"TEXP",
"CONDITIONS",
)
dtypes = ("S12", "S25", "S12", "S13", "f4", "f4", "S11", "S10", "f4", "S25")
multi_tab = Table(names=tab_names, dtype=dtypes, masked=True)
for kk, mask in enumerate(all_masks):
# Loop on observations
if all_obs[kk] is not None:
for obs in all_obs[kk]:
maskobs = copy.deepcopy(mask)
maskobs["DATE_OBS"] = obs["DATE"]
maskobs["TEXP"] = obs["TEXP"]
maskobs["DISPERSER"] = obs["DISPERSER"]
maskobs["CONDITIONS"] = obs["CONDITIONS"]
# Add row
multi_tab.add_row(maskobs)
else:
multi_tab.add_row(mask)
multi_tab.write(multi_file, format="ascii.fixed_width", delimiter="|")
print("Wrote file {:s}".format(multi_file))
def build_targets(field, path='./'):
'''Top-level program to build target info
Parameters:
-----------
field: tuple
(Name, ra, dec)
'''
# MMT
mmt_masks, mmt_obs, mmt_targs = mmt_targets(field)
# DEIMOS
deimos_sex, deimos_masks, deimos_obs, deimos_targs = deimos_targets(field)
# COLLATE
all_masks = deimos_masks + mmt_masks
all_obs = deimos_obs + mmt_obs
all_sex = vstack([deimos_sex, mmt_targs],
join_type='inner') # Use vstack when needed
# Generate Target table
targ_file = xcasbahu.get_filename(field, 'TARGETS')
cut_sex = all_sex[[
'TARG_RA', 'TARG_DEC', 'EPOCH', 'TARG_ID', 'TARG_MAG', 'TARG_IMG',
'INSTR', 'MASK_NAME'
]]
#cut_sex.write(targ_file,overwrite=True)
cut_sex.write(targ_file, format='ascii.fixed_width', delimiter='|')
print('Wrote file {:s}'.format(targ_file))
# Generate MULTI_OBJ file
multi_file = xcasbahu.get_filename(field, 'MULTI_OBJ')
tab_names = ('INSTR', 'MASK_NAME', 'MASK_RA', 'MASK_DEC', 'MASK_EPOCH',
'MASK_PA', 'DATE_OBS', 'DISPERSER', 'TEXP', 'CONDITIONS')
dtypes = ('S12', 'S25', 'S12', 'S13', 'f4', 'f4', 'S11', 'S10', 'f4',
'S25')
multi_tab = Table(names=tab_names, dtype=dtypes, masked=True)
for kk, mask in enumerate(all_masks):
# Loop on observations
if all_obs[kk] is not None:
for obs in all_obs[kk]:
maskobs = copy.deepcopy(mask)
maskobs['DATE_OBS'] = obs['DATE']
maskobs['TEXP'] = obs['TEXP']
maskobs['DISPERSER'] = obs['DISPERSER']
maskobs['CONDITIONS'] = obs['CONDITIONS']
# Add row
multi_tab.add_row(maskobs)
else:
multi_tab.add_row(mask)
multi_tab.write(multi_file, format='ascii.fixed_width', delimiter='|')
print('Wrote file {:s}'.format(multi_file))
def build_targets(field,path='./'):
'''Top-level program to build target info
Parameters:
-----------
field: tuple
(Name, ra, dec)
'''
# DEIMOS
deimos_sex, deimos_masks, deimos_obs, deimos_targs = deimos_targets(field)
# MMT
mmt_masks = []
mmt_obs = []
# COLLATE
all_masks = deimos_masks + mmt_masks
all_obs = deimos_obs + mmt_obs
all_sex = deimos_sex # Use vstack when needed
# Generate Target table
targ_file = xcasbahu.get_filename(field,'TARGETS')
cut_sex = all_sex[['TARG_RA','TARG_DEC','EPOCH','TARG_ID',
'TARG_MAG','TARG_IMG','INSTR','MASK_NAME']]
#cut_sex.write(targ_file,overwrite=True)
cut_sex.write(targ_file,format='ascii.fixed_width',delimiter='|')
print('Wrote file {:s}'.format(targ_file))
# Generate MULTI_OBJ file
multi_file = xcasbahu.get_filename(field,'MULTI_OBJ')
tab_names=('INSTR', 'MASK_NAME', 'MASK_RA', 'MASK_DEC', 'MASK_EPOCH',
'MASK_PA', 'DATE_OBS', 'DISPERSER', 'TEXP', 'CONDITIONS')
dtypes=('S12', 'S25', 'S12', 'S13', 'f4',
'f4', 'S11', 'S10', 'f4', 'S25')
multi_tab = Table(names=tab_names, dtype=dtypes, masked=True)
for kk,mask in enumerate(all_masks):
# Loop on observations
if all_obs[kk] is not None:
for obs in all_obs[kk]:
maskobs = copy.deepcopy(mask)
maskobs['DATE_OBS'] = obs['DATE']
maskobs['TEXP'] = obs['TEXP']
maskobs['DISPERSER'] = obs['DISPERSER']
maskobs['CONDITIONS'] = obs['CONDITIONS']
# Add row
multi_tab.add_row(maskobs)
else:
multi_tab.add_row(mask)
multi_tab.write(multi_file,format='ascii.fixed_width',delimiter='|')
print('Wrote file {:s}'.format(multi_file))
def build_imaging(field, obs_path=None, path='./'):
"""Top-level program to build images
Parameters
----------
field : tuple
(Name, ra, dec)
obs_path : str, optional
"""
if obs_path is None:
obs_path = os.getenv('DROPBOX_DIR')+'CASBAH_Observing/'
import shutil
# DEIMOS mask image
targ_file = xcasbahu.get_filename(field,'TARGETS')
targets = Table.read(targ_file,delimiter='|',
format='ascii.fixed_width',
fill_values=[('--','0','MASK_NAME')])
deimos_targ = np.where(targets['INSTR'] == 'DEIMOS')[0]
if len(deimos_targ) > 0:
# Search for LBT image
msk_img = targets[deimos_targ]['TARG_IMG'][0]
img_fil = glob.glob(obs_path+field[0]+'/IMG/LBT/'+msk_img+'*')
if len(img_fil) == 1:
# Copy
path = os.getenv('CASBAH_GALAXIES')
shutil.copy2(img_fil[0], path+'/'+field[0]+'/')
print('Copied {:s}'.format(img_fil[0]))
else:
raise ValueError('Need to provide the image! {:s}'.format(
field[0]+'/IMG/LBT/'+msk_img))
def build_imaging(field, obs_path=None, path='./'):
"""Top-level program to build images
Parameters
----------
field : tuple
(Name, ra, dec)
obs_path : str, optional
"""
if obs_path is None:
obs_path = os.getenv('DROPBOX_DIR') + 'CASBAH_Observing/'
import shutil
# DEIMOS mask image
targ_file = xcasbahu.get_filename(field, 'TARGETS')
targets = Table.read(targ_file,
delimiter='|',
format='ascii.fixed_width',
fill_values=[('--', '0', 'MASK_NAME')])
deimos_targ = np.where(targets['INSTR'] == 'DEIMOS')[0]
if len(deimos_targ) > 0:
# Search for LBT image
msk_img = targets[deimos_targ]['TARG_IMG'][0]
img_fil = glob.glob(obs_path + field[0] + '/IMG/LBT/' + msk_img + '*')
if len(img_fil) == 1:
# Copy
path = os.getenv('CASBAH_GALAXIES')
shutil.copy2(img_fil[0], path + '/' + field[0] + '/')
print('Copied {:s}'.format(img_fil[0]))
else:
raise ValueError(
'Need to provide the image! {:s}'.format(field[0] +
'/IMG/LBT/' +
msk_img))
def load_field(field):
''' Load up CASBAH data for a given field
Parameters:
-----------
field: tuple
(Name, ra, dec)
Returns:
--------
lfield:
Loaded IgmGalaxyField class
'''
reload(xcgmf)
reload(xcasbahu)
lfield = xcgmf.IgmGalaxyField(field[0], (field[1], field[2]))
# Load targets
targ_file = xcasbahu.get_filename(field, 'TARGETS')
lfield.targets = Table.read(targ_file,
delimiter='|',
format='ascii.fixed_width',
fill_values=[('--', '0', 'MASK_NAME')])
# Load observing details for multi-object follow-up
obs_file = xcasbahu.get_filename(field, 'MULTI_OBJ')
lfield.observing = Table.read(obs_file,
delimiter='|',
format='ascii.fixed_width',
fill_values=[('--', '0', 'DATE_OBS', 'TEXP')
])
# Load galaxies
sdss_file = xcasbahu.get_filename(field, 'SDSS')
sdss_tab = Table.read(sdss_file)
# VSTACK
hectospec_file = xcasbahu.get_filename(field, 'HECTOSPEC')
lfield.galaxies = sdss_tab
# Return
return lfield
def load_field(field):
''' Load up CASBAH data for a given field
Parameters:
-----------
field: tuple
(Name, ra, dec)
Returns:
--------
lfield:
Loaded IgmGalaxyField class
'''
reload(xcgmf)
reload(xcasbahu)
lfield = xcgmf.IgmGalaxyField(field[0], (field[1], field[2]))
# Load targets
targ_file = xcasbahu.get_filename(field, 'TARGETS')
lfield.targets = Table.read(
targ_file,
delimiter='|',
format='ascii.fixed_width',
fill_values=[('--', '0', 'MASK_NAME')])
# Load observing details for multi-object follow-up
obs_file = xcasbahu.get_filename(field, 'MULTI_OBJ')
lfield.observing = Table.read(
obs_file,
delimiter='|',
format='ascii.fixed_width',
fill_values=[('--', '0', 'DATE_OBS', 'TEXP')])
# Load galaxies
sdss_file = xcasbahu.get_filename(field, 'SDSS')
sdss_tab = Table.read(sdss_file)
# VSTACK
lfield.galaxies = sdss_tab
# Return
return lfield
def build_sdss(radius=2.0 * u.deg):
""" Grab SDSS photometry and spectra for those fields in the footprint
Includes BOSS data.
"""
fields = [("PG1407+265", 212.34957 * u.deg, 26.30585 * u.deg)]
for field in fields:
# Directory
if not os.path.exists(field[0]):
os.makedirs(field[0])
# Grab SDSS data + write to folder
sdss_fil = xcasbahu.get_filename(field, "SDSS")
print("CASBAH_SDSS: Building {:s}".format(sdss_fil))
print("CASBAH_SDSS: Be patient..")
xcgd.grab_sdss_spectra((field[1], field[2]), radius=radius, outfil=sdss_fil, maxsep=20.0, zmin=500.0 / 3e5)
def build_sdss(radius=2.0 * u.deg):
''' Grab SDSS photometry and spectra for those fields in the footprint
Includes BOSS data.
'''
fields = [('PG1407+265', 212.34957 * u.deg, 26.30585 * u.deg)]
for field in fields:
# Directory
if not os.path.exists(field[0]):
os.makedirs(field[0])
# Grab SDSS data + write to folder
sdss_fil = xcasbahu.get_filename(field, 'SDSS')
print('CASBAH_SDSS: Building {:s}'.format(sdss_fil))
print('CASBAH_SDSS: Be patient..')
xcgd.grab_sdss_spectra((field[1], field[2]),
radius=radius,
outfil=sdss_fil,
maxsep=20.,
zmin=500. / 3e5)
def build_sdss(field, radius=2.0*u.deg):
""" Grab SDSS photometry and spectra for those fields in the footprint
Includes BOSS data.
Parameters
----------
field : tuple
(name, ra_deg, dec_deg)
radius : Angle or Quantity, optional
"""
# Directory
if not os.path.exists(field[0]):
os.makedirs(field[0])
# Grab SDSS data + write to folder
sdss_fil = xcasbahu.get_filename(field,'SDSS')
print('CASBAH_SDSS: Building {:s}'.format(sdss_fil))
print('CASBAH_SDSS: Be patient..')
grab_sdss_spectra((field[1],field[2]),
radius=radius, outfil=sdss_fil, maxsep=20., zmin=500./3e5)
def build_sdss(field, radius=2.0 * u.deg):
""" Grab SDSS photometry and spectra for those fields in the footprint
Includes BOSS data.
Parameters
----------
field : tuple
(name, ra_deg, dec_deg)
radius : Angle or Quantity, optional
"""
# Directory
if not os.path.exists(field[0]):
os.makedirs(field[0])
# Grab SDSS data + write to folder
sdss_fil = xcasbahu.get_filename(field, 'SDSS')
print('CASBAH_SDSS: Building {:s}'.format(sdss_fil))
print('CASBAH_SDSS: Be patient..')
grab_sdss_spectra((field[1], field[2]),
radius=radius,
outfil=sdss_fil,
maxsep=20.,
zmin=500. / 3e5)
def build_spectra(field, obs_path=None, path='./'):
"""Top-level program to build spectra files
Parameters
----------
field : tuple
(Name, ra, dec)
"""
if obs_path is None:
obs_path = os.getenv('DROPBOX_DIR') + 'CASBAH_Observing/'
"""
Hectospec
"""
## DEAL WITH DUPLICATES (TAKE HIGHER ZQ)
#HDU0: wavelengths (Angstroms)
#HDU1: sky-subtracted, variance-weighted coadded spectra (total counts)
#HDU2: inverse variance (counts)
#HDU3: AND bad pixel mask
#HDU4: OR bad pixel mask
#HDU5: Plugmap structure (fiber info)
#HDU6: Combined sky spectra
#HDU7: Summed (unweighted) spectra
# Load up the data
hecto_path = '/Galx_Spectra/Hectospec/'
spfiles = glob.glob(obs_path + field[0] + hecto_path + 'spHect-*')
spfiles.sort()
for spfile in spfiles:
if 'zcat' not in spfile: # Spectra
hdu = fits.open(spfile)
print('Reading {:s}'.format(spfile))
wave = hdu[0].data
flux = hdu[1].data
ivar = hdu[2].data
sig = np.zeros_like(flux)
gd = ivar > 0.
sig[gd] = np.sqrt(ivar[gd])
tbl = Table(hdu[5].data)
if 'hecto_wave' not in locals():
hecto_wave, hecto_flux, hecto_sig, hecto_stbl = wave, flux, sig, tbl
else:
hecto_wave = np.concatenate((hecto_wave, wave))
hecto_flux = np.concatenate((hecto_flux, flux))
hecto_sig = np.concatenate((hecto_sig, sig))
hecto_stbl = vstack([hecto_stbl, tbl])
else:
tmp = Table.read(spfile) # z values
if 'hecto_ztbl' not in locals():
hecto_ztbl = tmp
else:
hecto_ztbl = vstack([hecto_ztbl, tmp])
# Check
if len(hecto_stbl) != len(hecto_ztbl):
raise ValueError("Bad Hecto tables..")
# Objects only
gdobj = np.where(hecto_ztbl['MAG'] > 1.)[0]
nobj = len(gdobj)
# Check for duplicates
idval = np.array(hecto_ztbl[gdobj]['ID']).astype(int)
uni, counts = np.unique(idval, return_counts=True)
if len(uni) != nobj:
warnings.warn("Resetting duplicate ID values using the targs table")
# Load targets file
targ_file = xcasbahu.get_filename(field, 'TARGETS')
targs = Table.read(targ_file,
delimiter='|',
format='ascii.fixed_width',
fill_values=[('--', '0', 'MASK_NAME')])
tcoord = SkyCoord(ra=targs['TARG_RA'] * u.deg,
dec=targs['TARG_DEC'] * u.deg)
# Loop on duplicates
dup = np.where(counts > 1)[0]
for idup in dup:
dobj = np.where(hecto_ztbl['ID'] == str(uni[idup]))[0]
# Loop on objects
for idobj in dobj:
dcoord = SkyCoord(ra=hecto_stbl['RA'][idobj] * u.deg,
dec=hecto_stbl['DEC'][idobj] * u.deg)
# Match by RA/DEC
mt = np.argmin(dcoord.separation(tcoord))
# Reset ID
#xdb.set_trace()
print('Setting ID to {:s} from {:s}'.format(
str(targs['TARG_ID'][mt]), hecto_ztbl['ID'][idobj]))
hecto_ztbl['ID'][idobj] = str(targs['TARG_ID'][mt])
# Double check
idval = np.array(hecto_ztbl[gdobj]['ID']).astype(int)
uni, counts = np.unique(idval, return_counts=True)
if len(uni) != nobj:
xdb.set_trace()
raise ValueError("Should not get here")
# Generate the final Table
hecto_spec = Table()
hecto_spec.add_column(hecto_stbl['RA'][gdobj])
hecto_spec.add_column(hecto_stbl['DEC'][gdobj])
hecto_spec['RA'].unit = u.deg
hecto_spec['DEC'].unit = u.deg
hecto_spec.add_column(hecto_ztbl['Z'][gdobj])
hecto_spec.add_column(hecto_ztbl['Z_ERR'][gdobj])
hecto_spec.add_column(hecto_ztbl['ZQ'][gdobj])
hecto_spec.add_column(hecto_ztbl['APERTURE'][gdobj])
hecto_spec.add_column(hecto_ztbl['ID'][gdobj]) # May wish to recast as int
hecto_spec.add_column(hecto_ztbl['MAG'][gdobj])
hecto_spec.add_column(Column(['MMT'] * nobj, name='TELESCOPE'))
hecto_spec.add_column(Column(['Hectospec'] * nobj, name='INSTRUMENT'))
hecto_spec.add_column(Column(hecto_wave[gdobj, :], name='WAVE'))
hecto_spec.add_column(Column(hecto_flux[gdobj, :], name='FLUX'))
hecto_spec.add_column(Column(hecto_sig[gdobj, :], name='SIG'))
# Write
hectospec_file = xcasbahu.get_filename(field, 'HECTOSPEC')
hecto_spec.write(hectospec_file, overwrite=True)
def build_targets(field, obs_path=None, path='./'):
"""Top-level program to build target info
Parameters
----------
field : tuple
(Name, ra, dec)
"""
if obs_path is None:
obs_path = os.getenv('DROPBOX_DIR') + 'CASBAH_Observing/'
targ_list = []
# MMT
hecto_masks, hecto_obs, hecto_targs = hecto_targets(field, obs_path)
if hecto_targs is not None:
targ_list = targ_list + [hecto_targs]
# DEIMOS
deimos_sex, deimos_masks, deimos_obs, deimos_targs = deimos_targets(
field, obs_path)
if deimos_masks is None:
deimos_masks = []
deimos_obs = []
else:
targ_list = [deimos_sex] + targ_list
# COLLATE
all_masks = deimos_masks + hecto_masks
all_obs = deimos_obs + hecto_obs
all_sex = vstack(targ_list, join_type='inner') # Use vstack when needed
# Out path
outpath = xcasbahu.get_filename(field, 'FIELD_PATH')
if not exists(outpath):
makedirs(outpath)
# Generate Target table
targ_file = xcasbahu.get_filename(field, 'TARGETS')
cut_sex = all_sex[[
'TARG_RA', 'TARG_DEC', 'EPOCH', 'TARG_ID', 'TARG_MAG', 'TARG_IMG',
'INSTR', 'MASK_NAME'
]]
#cut_sex.write(targ_file,overwrite=True)
cut_sex.write(targ_file, format='ascii.fixed_width', delimiter='|')
print('Wrote file {:s}'.format(targ_file))
# Generate MULTI_OBJ file
multi_file = xcasbahu.get_filename(field, 'MULTI_OBJ')
tab_names = ('INSTR', 'MASK_NAME', 'MASK_RA', 'MASK_DEC', 'MASK_EPOCH',
'MASK_PA', 'DATE_OBS', 'DISPERSER', 'TEXP', 'CONDITIONS')
dtypes = ('S12', 'S25', 'S12', 'S13', 'f4', 'f4', 'S11', 'S10', 'f4',
'S25')
multi_tab = Table(names=tab_names, dtype=dtypes, masked=True)
for kk, mask in enumerate(all_masks):
# Loop on observations
if all_obs[kk] is not None:
for obs in all_obs[kk]:
maskobs = copy.deepcopy(mask)
maskobs['DATE_OBS'] = obs['DATE']
maskobs['TEXP'] = obs['TEXP']
maskobs['DISPERSER'] = obs['DISPERSER']
maskobs['CONDITIONS'] = obs['CONDITIONS']
# Add row
multi_tab.add_row(maskobs)
else:
multi_tab.add_row(mask)
multi_tab.write(multi_file, format='ascii.fixed_width', delimiter='|')
print('Wrote file {:s}'.format(multi_file))
def build_spectra(field, obs_path=None, path='./'):
"""Top-level program to build spectra files
Parameters
----------
field : tuple
(Name, ra, dec)
"""
if obs_path is None:
obs_path = os.getenv('DROPBOX_DIR')+'CASBAH_Observing/'
"""
Hectospec
"""
## DEAL WITH DUPLICATES (TAKE HIGHER ZQ)
#HDU0: wavelengths (Angstroms)
#HDU1: sky-subtracted, variance-weighted coadded spectra (total counts)
#HDU2: inverse variance (counts)
#HDU3: AND bad pixel mask
#HDU4: OR bad pixel mask
#HDU5: Plugmap structure (fiber info)
#HDU6: Combined sky spectra
#HDU7: Summed (unweighted) spectra
# Load up the data
hecto_path = '/Galx_Spectra/Hectospec/'
spfiles = glob.glob(obs_path+field[0]+hecto_path+'spHect-*')
spfiles.sort()
for spfile in spfiles:
if 'zcat' not in spfile: # Spectra
hdu = fits.open(spfile)
print('Reading {:s}'.format(spfile))
wave = hdu[0].data
flux = hdu[1].data
ivar = hdu[2].data
sig = np.zeros_like(flux)
gd = ivar > 0.
sig[gd] = np.sqrt(ivar[gd])
tbl = Table(hdu[5].data)
if 'hecto_wave' not in locals():
hecto_wave, hecto_flux, hecto_sig, hecto_stbl = wave, flux, sig, tbl
else:
hecto_wave = np.concatenate((hecto_wave, wave))
hecto_flux = np.concatenate((hecto_flux, flux))
hecto_sig = np.concatenate((hecto_sig, sig))
hecto_stbl = vstack([hecto_stbl,tbl])
else:
tmp = Table.read(spfile) # z values
if 'hecto_ztbl' not in locals():
hecto_ztbl = tmp
else:
hecto_ztbl = vstack([hecto_ztbl,tmp])
# Check
if len(hecto_stbl) != len(hecto_ztbl):
raise ValueError("Bad Hecto tables..")
# Objects only
gdobj = np.where(hecto_ztbl['MAG'] > 1.)[0]
nobj = len(gdobj)
# Check for duplicates
idval = np.array(hecto_ztbl[gdobj]['ID']).astype(int)
uni, counts = np.unique(idval, return_counts=True)
if len(uni) != nobj:
warnings.warn("Resetting duplicate ID values using the targs table")
# Load targets file
targ_file = xcasbahu.get_filename(field, 'TARGETS')
targs = Table.read(targ_file,delimiter='|', format='ascii.fixed_width',
fill_values=[('--','0','MASK_NAME')])
tcoord = SkyCoord(ra=targs['TARG_RA']*u.deg, dec=targs['TARG_DEC']*u.deg)
# Loop on duplicates
dup = np.where(counts>1)[0]
for idup in dup:
dobj = np.where(hecto_ztbl['ID'] == str(uni[idup]))[0]
# Loop on objects
for idobj in dobj:
dcoord = SkyCoord(ra=hecto_stbl['RA'][idobj]*u.deg,
dec=hecto_stbl['DEC'][idobj]*u.deg)
# Match by RA/DEC
mt = np.argmin(dcoord.separation(tcoord))
# Reset ID
#xdb.set_trace()
print('Setting ID to {:s} from {:s}'.format(
str(targs['TARG_ID'][mt]), hecto_ztbl['ID'][idobj]))
hecto_ztbl['ID'][idobj] = str(targs['TARG_ID'][mt])
# Double check
idval = np.array(hecto_ztbl[gdobj]['ID']).astype(int)
uni, counts = np.unique(idval, return_counts=True)
if len(uni) != nobj:
xdb.set_trace()
raise ValueError("Should not get here")
# Generate the final Table
hecto_spec = Table()
hecto_spec.add_column(hecto_stbl['RA'][gdobj])
hecto_spec.add_column(hecto_stbl['DEC'][gdobj])
hecto_spec['RA'].unit = u.deg
hecto_spec['DEC'].unit = u.deg
hecto_spec.add_column(hecto_ztbl['Z'][gdobj])
hecto_spec.add_column(hecto_ztbl['Z_ERR'][gdobj])
hecto_spec.add_column(hecto_ztbl['ZQ'][gdobj])
hecto_spec.add_column(hecto_ztbl['APERTURE'][gdobj])
hecto_spec.add_column(hecto_ztbl['ID'][gdobj]) # May wish to recast as int
hecto_spec.add_column(hecto_ztbl['MAG'][gdobj])
hecto_spec.add_column(Column(['MMT']*nobj, name='TELESCOPE'))
hecto_spec.add_column(Column(['Hectospec']*nobj, name='INSTRUMENT'))
hecto_spec.add_column(Column(hecto_wave[gdobj,:], name='WAVE'))
hecto_spec.add_column(Column(hecto_flux[gdobj,:], name='FLUX'))
hecto_spec.add_column(Column(hecto_sig[gdobj,:], name='SIG'))
# Write
hectospec_file = xcasbahu.get_filename(field,'HECTOSPEC')
hecto_spec.write(hectospec_file, overwrite=True)
def deimos_targets(field, gc=None, outfil=None, replot=True,
reset_layers=False):
'''
Call with gc to speed things up
'''
import matplotlib.cm as cm
import matplotlib.patches as patches
reload(xra)
# Init
# Mask dimensions
smsk_dim = (7., 16.6) # arcmin (approximate)
smsk_ang = np.arctan(smsk_dim[0]/smsk_dim[1])
smsk_diag = np.sqrt(smsk_dim[0]**2 + smsk_dim[1]**2)/2.
all_smsk_ang = [-1.*smsk_ang, smsk_ang, np.pi-smsk_ang, np.pi+smsk_ang]
# Coordinates
fcoord = SkyCoord(ra=field[1],dec=field[2])
if outfil is None:
outfil = xcasu.get_filename(field,'DEIMOS_TARG_FIG')
# Load field
lfield = xcasl.load_field(field)
targ_coord = SkyCoord(ra=lfield.targets['TARG_RA']*u.deg,
dec=lfield.targets['TARG_DEC']*u.deg)
all_pa = fcoord.position_angle(targ_coord)
all_sep = fcoord.separation(targ_coord).to('arcmin')
# Targets
deimos_targ = np.where(lfield.targets['INSTR'] == 'DEIMOS')[0]
#dra = all_sep[deimos_targ]*np.sin(all_pa[deimos_targ])
#ddec = all_sep[deimos_targ]*np.cos(all_pa[deimos_targ])
# Image
path = os.getenv('CASBAH_GALAXIES')
img_fil = path+'/'+field[0]+'/'+lfield.targets[deimos_targ]['TARG_IMG'][0]
gfil = glob.glob(img_fil+'*')
if len(gfil) != 1:
raise ValueError('Image not found! {:s}'.format(img_fil))
else:
img_fil = gfil[0]
#hdu = fits.open(img_fil)
#w = wcs.WCS(hdu[0].header,fix=True)
#img = hdu[0].data
'''
# Size
pix_qso = w.wcs_world2pix(np.array([[field[1].value,field[2].value]]), 1)
corners = [ [0.,0.], [0.,img.shape[0]], [img.shape[1],0.], [img.shape[1],img.shape[0]]]
rad_corners = w.wcs_pix2world(np.array(corners), 1) # deg but no units
mx_rad = [0.,0.]
for rad in rad_corners:
c_off, _ = xra.offsets(fcoord, tuple(rad))
for ii in range(2):
mx_rad[ii] = np.maximum(
mx_rad[ii],np.abs(c_off[ii].to('arcmin').value))
imsize = 2.*np.maximum(mx_rad[0],mx_rad[1])
'''
# Start the plot
#if outfil is not None:
# pp = PdfPages(outfil)
# Targets only
plt.figure(figsize=(8, 4.9))
plt.clf()
plt.suptitle('{:s}: DEIMOS Targets (from LBT imaging)'.format(field[0])
,fontsize=19.)
# Plot the Image
if gc is None:
gc = aplpy.FITSFigure(img_fil)
radius = 25./60/2. #0.01 # deg
if replot:
gc.recenter(field[1].value, field[2].value,radius=radius)
# This next one is a bit expensive
gc.show_grayscale(vmin=300., vmax=3000.,stretch='arcsinh',invert='True')
# Masks
msk_clrs = ['blue', 'red', 'green', 'orange']
deimos_obs = lfield.observing[np.where(
lfield.observing['INSTR']=='DEIMOS')[0]]
unimsk = np.unique(np.array(deimos_obs['MASK_NAME']))
for ii,msk in enumerate(unimsk):
mt = np.where(deimos_obs['MASK_NAME'] == msk)[0]
if not deimos_obs['DATE_OBS'].mask[mt[0]]:
# RA,DEC offset of center
mask_rad = xra.stod1((deimos_obs['MASK_RA'][mt[0]],
deimos_obs['MASK_DEC'][mt[0]]))
mask_pa = deimos_obs['MASK_PA'][mt[0]]*np.pi/180.
# RA/DEC offsets of corners
rect_x = [smsk_diag*np.sin(smsk_ang+mask_pa) for smsk_ang in all_smsk_ang]
rect_y = [smsk_diag*np.cos(smsk_ang+mask_pa) for smsk_ang in all_smsk_ang]
#xdb.set_trace()
prect_y = mask_rad[1].value + np.array(rect_y+[rect_y[0]])/60.
prect_x = mask_rad[0].value + np.array(rect_x+[rect_x[0]])/60./np.cos(prect_y*np.pi/180.)
'''
coord0 = SkyCoord(ra=prect_x[0]*u.deg,dec=prect_y[0]*u.deg)
coord2 = SkyCoord(ra=prect_x[2]*u.deg,dec=prect_y[2]*u.deg)
rcoord0 = SkyCoord(ra=rect_x[0]*u.arcmin,dec=rect_y[0]*u.arcmin)
rcoord2 = SkyCoord(ra=rect_x[2]*u.arcmin,dec=rect_y[2]*u.arcmin)
sep02 = coord0.separation(coord2).to('arcmin')
rsep02 = rcoord0.separation(rcoord2).to('arcmin')
print(sep02)
print(rsep02)
print(smsk_diag*2.)
xdb.set_trace()
'''
# Reshape
xy = np.zeros((2,5))
xy[0,:] = prect_x
xy[1,:] = prect_y
#xdb.set_trace()
gc.show_lines([xy],color=msk_clrs[ii])#,alpha=0.5)
# Markers
# Observed targets
sub_targ = np.where((lfield.targets['MASK_NAME']==msk)
& (lfield.targets['INSTR']=='DEIMOS'))[0]
obs_targ_tab, obs_dict, obs_idx = lfield.get_observed(radius*u.deg,
subtab=lfield.targets[sub_targ])
ra_obs_targ = lfield.targets[sub_targ[obs_idx]]['TARG_RA']
dec_obs_targ = lfield.targets[sub_targ[obs_idx]]['TARG_DEC']
gc.show_markers(ra_obs_targ, dec_obs_targ, edgecolor=msk_clrs[ii],
facecolor='none', marker='o', s=50)#, alpha=0.5)
# QSO
gc.show_markers(field[1].value, field[2].value, edgecolor='lightgreen', facecolor='none',
marker='s', s=10, alpha=0.5)
# Label
#gc.add_label(field[1].value, field[2].value, 'Q', color='green')
if outfil != None:
gc.save(outfil)
'''
def build_targets(field, obs_path=None, path='./'):
"""Top-level program to build target info
Parameters
----------
field : tuple
(Name, ra, dec)
"""
if obs_path is None:
obs_path = os.getenv('DROPBOX_DIR')+'CASBAH_Observing/'
targ_list = []
# MMT
hecto_masks, hecto_obs, hecto_targs = hecto_targets(field, obs_path)
if hecto_targs is not None:
targ_list = targ_list + [hecto_targs]
# DEIMOS
deimos_sex, deimos_masks, deimos_obs, deimos_targs = deimos_targets(field, obs_path)
if deimos_masks is None:
deimos_masks = []
deimos_obs = []
else:
targ_list = [deimos_sex] + targ_list
# COLLATE
all_masks = deimos_masks + hecto_masks
all_obs = deimos_obs + hecto_obs
all_sex = vstack(targ_list, join_type='inner') # Use vstack when needed
# Out path
outpath = xcasbahu.get_filename(field, 'FIELD_PATH')
if not exists(outpath):
makedirs(outpath)
# Generate Target table
targ_file = xcasbahu.get_filename(field, 'TARGETS')
cut_sex = all_sex[['TARG_RA','TARG_DEC','EPOCH','TARG_ID',
'TARG_MAG','TARG_IMG','INSTR','MASK_NAME']]
#cut_sex.write(targ_file,overwrite=True)
cut_sex.write(targ_file,format='ascii.fixed_width',delimiter='|')
print('Wrote file {:s}'.format(targ_file))
# Generate MULTI_OBJ file
multi_file = xcasbahu.get_filename(field,'MULTI_OBJ')
tab_names=('INSTR', 'MASK_NAME', 'MASK_RA', 'MASK_DEC', 'MASK_EPOCH',
'MASK_PA', 'DATE_OBS', 'DISPERSER', 'TEXP', 'CONDITIONS')
dtypes=('S12', 'S25', 'S12', 'S13', 'f4',
'f4', 'S11', 'S10', 'f4', 'S25')
multi_tab = Table(names=tab_names, dtype=dtypes, masked=True)
for kk,mask in enumerate(all_masks):
# Loop on observations
if all_obs[kk] is not None:
for obs in all_obs[kk]:
maskobs = copy.deepcopy(mask)
maskobs['DATE_OBS'] = obs['DATE']
maskobs['TEXP'] = obs['TEXP']
maskobs['DISPERSER'] = obs['DISPERSER']
maskobs['CONDITIONS'] = obs['CONDITIONS']
# Add row
multi_tab.add_row(maskobs)
else:
multi_tab.add_row(mask)
multi_tab.write(multi_file,format='ascii.fixed_width',delimiter='|')
print('Wrote file {:s}'.format(multi_file))
def hectospec_targets(field, outfil=None):
# Init
fcoord = SkyCoord(ra=field[1],dec=field[2])
if outfil is None:
outfil = xcasu.get_filename(field,'HECTO_TARG_FIG')
# Load field
lfield = xcasl.load_field(field)
targ_coord = SkyCoord(ra=lfield.targets['TARG_RA']*u.deg,
dec=lfield.targets['TARG_DEC']*u.deg)
all_pa = fcoord.position_angle(targ_coord)
all_sep = fcoord.separation(targ_coord).to('arcmin')
# Start the plot
if outfil is not None:
pp = PdfPages(outfil)
# Targets only
plt.figure(figsize=(8, 4.5))
plt.clf()
gs = gridspec.GridSpec(1,2)
plt.suptitle('{:s}: Hectospec Targets (from SDSS imaging)'.format(field[0])
,fontsize=19.)
##
# Hectospec first
for tt in range(2):
ax_hecto = plt.subplot(gs[tt])
# Read SDSS Image
if tt == 0:
imsize=60. # arcmin
else:
imsize=10. # arcmin
#Configs
if tt == 0:
hecto_obs = lfield.observing[np.where(
lfield.observing['INSTR']=='HECTOSPEC')[0]]
unimsk = np.unique(np.array(hecto_obs['MASK_NAME']))
for msk in unimsk:
mt = np.where(hecto_obs['MASK_NAME'] == msk)[0]
if not hecto_obs['DATE_OBS'].mask[mt[0]]:
# RA,DEC
rd_off, PA = xra.offsets(fcoord,
(hecto_obs['MASK_RA'][mt[0]],
hecto_obs['MASK_DEC'][mt[0]]),verbose=False)
# Plot
circ = plt.Circle((rd_off[0].to('arcmin').value,
rd_off[1].to('arcmin').value), 30.,
color='y', fill=False, alpha=0.5)
ax_hecto.add_artist(circ)
# Plot SDSS image
sdss_img, _ = xosdss.getimg(field[1],field[2], imsize)
ax_hecto.imshow(sdss_img,aspect='equal',
extent=(imsize/2., -imsize/2, -imsize/2.,imsize/2))
# Targets
hecto_targ = np.where(lfield.targets['INSTR'] == 'HECTOSPEC')[0]
ddec = all_sep[hecto_targ]*np.cos(all_pa[hecto_targ])
dra = all_sep[hecto_targ]*np.sin(all_pa[hecto_targ])
#xdb.set_trace()
ax_hecto.scatter(dra,ddec, marker='o',color='gray',s=10.,
facecolor='none',linewidth=0.3, alpha=0.5)
# Observed
obs_targ_tab, obs_dict, obs_idx = lfield.get_observed(imsize*u.arcmin,
subtab=lfield.targets[hecto_targ])
ax_hecto.scatter(dra[obs_idx],ddec[obs_idx], marker='o',color='gray',s=10.,
facecolor='none',linewidth=0.3)
# Labels
ax_hecto.set_xlabel('Relative ArcMin', fontsize=13)
ax_hecto.set_ylabel('Relative ArcMin', fontsize=13)
ax_hecto.set_xlim(imsize/2., -imsize/2.)
ax_hecto.set_ylim(-imsize/2., imsize/2.)
plt.tight_layout(pad=0.2,h_pad=0.3,w_pad=0.0)
if outfil is not None:
pp.savefig()
print('Wrote figure: {:s}'.format(outfil))
pp.close()
else:
plt.show()
