def detect_with_sep(event,
detect_thresh=2.,
npixels=8,
grow_seg=5,
gauss_fwhm=2.,
gsize=3,
im_wcs=None,
root='mycat'):
drz_file = event['fits_s3_key']
drz_file_bucket = event['fits_s3_bucket']
root = drz_file.split('/')[-1].split('_')[0]
s3 = boto3.resource('s3')
s3_client = boto3.client('s3')
bkt = s3.Bucket(drz_file_bucket)
bkt.download_file(drz_file,
'/tmp/{0}'.format(root),
ExtraArgs={"RequestPayer": "requester"})
im = fits.open('/tmp/{0}'.format(root))
im_wcs = wcs.WCS(im[1].header, relax=True)
data = im[1].data.byteswap().newbyteorder()
wht_data = im[2].data.byteswap().newbyteorder()
data_mask = np.cast[data.dtype](data == 0)
## Get AB zeropoint
if 'PHOTFNU' in im[0].header:
ZP = -2.5 * np.log10(im[0].header['PHOTFNU']) + 8.90
elif 'PHOTFLAM' in im[0].header:
ZP = (-2.5 * np.log10(im[0].header['PHOTFLAM']) - 21.10 -
5 * np.log10(im[0].header['PHOTPLAM']) + 18.6921)
else:
print(
'Couldn\'t find PHOTFNU or PHOTPLAM/PHOTFLAM keywords, use ZP=25')
return None
# Scale fluxes to mico-Jy
uJy_to_dn = 1 / (3631 * 1e6 * 10**(-0.4 * ZP))
err = 1 / np.sqrt(wht_data)
# set up the error array
err = 1 / np.sqrt(wht_data)
err[~np.isfinite(err)] = 0
mask = (err == 0)
# get the background
bkg = sep.Background(data, mask=mask, bw=32, bh=32, fw=3, fh=3)
bkg_data = bkg.back()
ratio = bkg.rms() / err
err_scale = np.median(ratio[(~mask) & np.isfinite(ratio)])
err *= err_scale
objects = sep.extract(data - bkg_data,
detect_thresh,
err=err,
mask=mask,
minarea=14,
filter_kernel=GAUSS_3_7x7,
filter_type='conv',
deblend_nthresh=32,
deblend_cont=0.005,
clean=True,
clean_param=1.,
segmentation_map=False)
catalog = Table(objects)
# add things to catalog
autoparams = [2.5, 3.5]
catalog['number'] = np.arange(len(catalog), dtype=np.int32) + 1
catalog['theta'] = np.clip(catalog['theta'], -np.pi / 2, np.pi / 2)
for c in ['a', 'b', 'x', 'y', 'theta']:
catalog = catalog[np.isfinite(catalog[c])]
catalog['ra'], catalog['dec'] = im_wcs.all_pix2world(
catalog['x'], catalog['y'], 1)
catalog['ra'].unit = u.deg
catalog['dec'].unit = u.deg
catalog['x_world'], catalog['y_world'] = catalog['ra'], catalog['dec']
kronrad, krflag = sep.kron_radius(data - bkg_data, catalog['x'],
catalog['y'], catalog['a'], catalog['b'],
catalog['theta'], 6.0)
kronrad *= autoparams[0]
kronrad[~np.isfinite(kronrad)] = autoparams[1]
kronrad = np.maximum(kronrad, autoparams[1])
kron_out = sep.sum_ellipse(data - bkg_data,
catalog['x'],
catalog['y'],
catalog['a'],
catalog['b'],
catalog['theta'],
kronrad,
subpix=5,
err=err)
kron_flux, kron_fluxerr, kron_flag = kron_out
kron_flux_flag = kron_flag
catalog['mag_auto_raw'] = ZP - 2.5 * np.log10(kron_flux)
catalog['magerr_auto_raw'] = 2.5 / np.log(10) * kron_fluxerr / kron_flux
catalog['mag_auto'] = catalog['mag_auto_raw'] * 1.
catalog['magerr_auto'] = catalog['magerr_auto_raw'] * 1.
catalog['kron_radius'] = kronrad * u.pixel
catalog['kron_flag'] = krflag
catalog['kron_flux_flag'] = kron_flux_flag
# Make a plot
im_data = im[1].data
im_shape = im_data.shape
im_data[np.isnan(im_data)] = 0.0
# Trim the top and bottom 1 percent of pixel values
top = np.percentile(im_data, 99)
im_data[im_data > top] = top
bottom = np.percentile(im_data, 1)
im_data[im_data < bottom] = bottom
# Scale the data.
im_data = im_data - im_data.min()
im_data = (im_data / im_data.max()) * 255.
im_data = np.uint8(im_data)
f, (ax) = plt.subplots(1, 1, sharex=True)
f.set_figheight(12)
f.set_figwidth(12)
ax.imshow(im_data, cmap="Greys", clim=(0, 255), origin='lower')
ax.plot(catalog['x'],
catalog['y'],
'o',
markeredgewidth=1,
markeredgecolor='red',
markerfacecolor='None')
ax.set_xlim([-0.05 * im_shape[1], 1.05 * im_shape[1]])
ax.set_ylim([-0.05 * im_shape[0], 1.05 * im_shape[0]])
f.savefig('/tmp/{0}.png'.format(root))
# Write the catalog to local disk
catalog.write('/tmp/{0}.catalog.fits'.format(root), format='fits')
# Write out to S3
s3 = boto3.resource('s3')
s3.meta.client.upload_file('/tmp/{0}.catalog.fits'.format(root),
event['s3_output_bucket'],
'{0}/{1}.catalog.fits'.format(root, root))
s3.meta.client.upload_file('/tmp/{0}.png'.format(root),
event['s3_output_bucket'],
'PNG/{0}.png'.format(root))
##
## Note: assumed fixed center for moonsep, and powerlaw index following
## trial and error with these parameters.
##
## params[0] -> dependence on moon alt. -> Z0.
## params[1] -> dependence on moon alt. -> Z1.
return params[0] + params[1] * np.abs(moonsep - 96.) ** 1.863
## Airmass to run provided by command line.
all_airmass = [1.0, 1.2, 1.6, 2.0, 2.4, 2.8, 3.0]
airmass = all_airmass[np.int(sys.argv[1])]
## CHH Moon model called for a grid of conditions.
dat = np.loadtxt('../../dat/moons_{:.1f}.txt'.format(airmass))
dat = Table(dat, names=['AIRMASS', 'MOONFRAC', 'MOONALT', 'MOONSEP', '4000', '6700', '7160', '8070', '9060'])
## Get normalisation.
norm = np.loadtxt('../../dat/moon_norm.txt')
norm = Table(norm, names=['AIRMASS', 'MOONFRAC', 'MOONALT', 'MOONSEP', '4000', '6700', '7160', '8070', '9060'])
## Normalisation dat.
for band in ['4000', '6700', '7160', '8070', '9060']:
dat[band] /= norm[band]
dat[band] = np.clip(dat[band], 1.0, None)
print(dat)
## Choose a band to define the expfac.
dat['EXPFAC'] = dat['4000']
def classify_targets(fits_table,
band_names=None,
lambda_eff=None,
out_path=None):
"""Tabulate fitting coordinates for SNe based on their fit results
See the ``create_empty_table`` function for the assumed input table format.
If ``band_names`` or ``lambda_eff`` are not given, they are taken from
``fits_table.meta``. Any targets having one or more fits with the string
'failed' in the message are skipped (case insensitive).
Args:
fits_table (Table): A table of fit results
band_names (list): List of band names used when fitting
lambda_eff (list): The effective wavelength of each band in angstroms
out_path (str): Optionally write results to file
Returns:
An astropy table of fitting coordinates
"""
if band_names is None or lambda_eff is None:
band_names = fits_table.meta['band_names']
lambda_eff = fits_table.meta['lambda_eff']
# Keep only objects that don't have failed fits in any band
fits_df = fits_table.to_pandas()
failed_fits = fits_df['message'].str.lower().str.contains('failed')
failed_ids = fits_df[failed_fits].obj_id.unique()
good_fits = fits_df[~fits_df.obj_id.isin(failed_ids)]
good_fits.set_index(['obj_id', 'source'], inplace=True)
out_table = Table(names=['obj_id', 'x', 'y'], dtype=['U100', float, float])
for obj_id in good_fits.index.unique(level='obj_id'):
try:
hsiao_data = good_fits.loc[obj_id, 'hsiao_x1']
redshift = hsiao_data[hsiao_data['band'] == 'all']['z'][0]
blue_bands, red_bands = utils.split_bands(band_names, lambda_eff,
redshift)
blue_bands = np.concatenate([blue_bands, ['blue']])
red_bands = np.concatenate([red_bands, ['red']])
hsiao_blue = hsiao_data[hsiao_data['band'].isin(blue_bands)]
hsiao_red = hsiao_data[hsiao_data['band'].isin(red_bands)]
hsiao_blue_chisq = hsiao_blue['chisq'].sum(
) / hsiao_blue['ndof'].sum()
hsiao_red_chisq = hsiao_red['chisq'].sum() / hsiao_red['ndof'].sum(
)
sn91bg_data = good_fits.loc[obj_id, 'sn91bg']
sn91bg_blue = sn91bg_data[sn91bg_data['band'].isin(blue_bands)]
sn91bg_red = sn91bg_data[sn91bg_data['band'].isin(red_bands)]
sn91bg_blue_chisq = sn91bg_blue['chisq'].sum(
) / sn91bg_blue['ndof'].sum()
sn91bg_red_chisq = sn91bg_red['chisq'].sum(
) / sn91bg_red['ndof'].sum()
except KeyError:
continue
else:
x = hsiao_blue_chisq - sn91bg_blue_chisq
y = hsiao_red_chisq - sn91bg_red_chisq
out_table.add_row([obj_id, x, y])
if out_path:
out_table.write(out_path)
return out_table
tbl_out.append((
os.path.basename(image),
hdulist[0].header['OBJECT'],
icra, icdec, iwidth, iheight,
ibox[0], ibox[1], ibox[2], ibox[3],
))
hdulist.close()
cra, cdec, width, height = to_ds9_box(box)
tbl_out.append((
'all', 'all',
cra, cdec, width, height,
box[0], box[1], box[2], box[3]
))
tbl_out = Table(np.array(tbl_out), names=[
'filename', 'objname',
'ra', 'dec', 'width', 'height',
'ramin', 'ramax', 'decmin', 'decmax',
])
tbl_out.write(out_file, format='ascii.commented_header')
with open(out_reg, 'w') as fo:
fo.write('global color=red\n')
for entry in tbl_out[:-1]:
filename, objname, icra, icdec, iwidth, iheight = [
entry[i] for i in range(6)]
fo.write('fk5; box({0},{1},{2},{3}, 0) # text={{{4}}}\n'.format(
icra, icdec, iwidth, iheight, "{0} {1}".format(
os.path.splitext(filename)[0], objname)))
fo.write('fk5; box({0},{1},{2},{3}, 0) # color=yellow'.format(
cra, cdec, width, height))
# create wcs file
minra, maxra, mindec, maxdec = box
def fetch_fermi_catalog(catalog, extension=None):
"""Fetch Fermi catalog data.
Reference: http://fermi.gsfc.nasa.gov/ssc/data/access/lat/.
The Fermi catalogs contain the following relevant catalog HDUs:
* 3FGL Catalog : LAT 4-year Point Source Catalog
* ``LAT_Point_Source_Catalog`` Point Source Catalog Table.
* ``ExtendedSources`` Extended Source Catalog Table.
* 2FGL Catalog : LAT 2-year Point Source Catalog
* ``LAT_Point_Source_Catalog`` Point Source Catalog Table.
* ``ExtendedSources`` Extended Source Catalog Table.
* 1FGL Catalog : LAT 1-year Point Source Catalog
* ``LAT_Point_Source_Catalog`` Point Source Catalog Table.
* 2FHL Catalog : Second Fermi-LAT Catalog of High-Energy Sources
* ``Count Map`` AIT projection 2D count image
* ``2FHL Source Catalog`` Main catalog
* ``Extended Sources`` Extended Source Catalog Table
* ``ROIs`` Regions of interest
* 1FHL Catalog : First Fermi-LAT Catalog of Sources above 10 GeV
* ``LAT_Point_Source_Catalog`` Point Source Catalog Table.
* ``ExtendedSources`` Extended Source Catalog Table.
* 2PC Catalog : LAT Second Catalog of Gamma-ray Pulsars
* ``PULSAR_CATALOG`` Pulsar Catalog Table.
* ``SPECTRAL`` Table of Pulsar Spectra Parameters.
* ``OFF_PEAK`` Table for further Spectral and Flux data for the Catalog.
Parameters
----------
catalog : {'3FGL', '2FGL', '1FGL', '1FHL', '2FHL', '2PC'}
Specifies which catalog to display.
extension : str
Specifies which catalog HDU to provide as a table (optional).
See list of catalog HDUs above.
Returns
-------
hdu_list (Default) : `~astropy.io.fits.HDUList`
Catalog FITS HDU list (for access to full catalog dataset).
catalog_table : `~astropy.table.Table`
Catalog table for a selected hdu extension.
Examples
--------
>>> from gammapy.catalog import fetch_fermi_catalog
>>> fetch_fermi_catalog('2FGL')
[<astropy.io.fits.hdu.image.PrimaryHDU at 0x3330790>,
<astropy.io.fits.hdu.table.BinTableHDU at 0x338b990>,
<astropy.io.fits.hdu.table.BinTableHDU at 0x3396450>,
<astropy.io.fits.hdu.table.BinTableHDU at 0x339af10>,
<astropy.io.fits.hdu.table.BinTableHDU at 0x339ff10>]
>>> from gammapy.catalog import fetch_fermi_catalog
>>> fetch_fermi_catalog('2FGL', 'LAT_Point_Source_Catalog')
<Table rows=1873 names= ... >
"""
BASE_URL = 'http://fermi.gsfc.nasa.gov/ssc/data/access/lat/'
if catalog == '3FGL':
url = BASE_URL + '4yr_catalog/gll_psc_v16.fit'
elif catalog == '2FGL':
url = BASE_URL + '2yr_catalog/gll_psc_v08.fit'
elif catalog == '1FGL':
url = BASE_URL + '1yr_catalog/gll_psc_v03.fit'
elif catalog == '1FHL':
url = BASE_URL + '1FHL/gll_psch_v07.fit'
elif catalog == '2FHL':
url = 'https://github.com/gammapy/gammapy-extra/raw/master/datasets/catalogs/fermi/gll_psch_v08.fit.gz'
elif catalog == '2PC':
url = BASE_URL + '2nd_PSR_catalog/2PC_catalog_v03.fits'
else:
ss = 'Invalid catalog: {0}\n'.format(catalog)
raise ValueError(ss)
filename = download_file(url, cache=True)
hdu_list = fits.open(filename)
if extension is None:
return hdu_list
# TODO: 2FHL doesn't have a 'CLASS1' column, just 'CLASS'
# It's probably better if we make a `SourceCatalog` class
# and then sub-class `FermiSourceCatalog` and `Fermi2FHLSourceCatalog`
# and handle catalog-specific stuff in these classes,
# trying to provide an as-uniform as possible API to the common catalogs.
table = Table(hdu_list[extension].data)
table['IS_GALACTIC'] = [_is_galactic(_) for _ in table['CLASS1']]
return table
SEDclasscolumn = Column(data=[seddata[n] if n in seddata else '$E$' for n in names], name="SED Class")
classification = {x[:split1].strip():"{0}".format(x[split2:].strip()) for x in lines[1:end]}
classificationcolumn = Column(data=[classification[n] if n in classification else '-' for n in names], name="Classification")
footnotes_start = lines.index('Classification Key\n') + 1
footer = "".join(["{0}{1} \\\\\n"
.format("${0}$".format(x[0])
if len(x) > 1 and x[1]==':'
else "\\newline" if len(x) <= 1
else x[0],
x[1:].strip()) for x in
lines[footnotes_start:]])
postbl = Table([Column(data=names, name='Source Name'),
Column(data=coords.ra.to_string(unit=u.hour, sep=':', precision=2), name='RA'),
Column(data=coords.dec.to_string(unit=u.deg, sep=':', precision=1), name='Dec'),
Column(data=radii, name='Radius'),
Column(data=(radii*5.1*u.kpc).to(u.pc, u.dimensionless_angles()), name='Phys. Radius'),
SEDclasscolumn,
classificationcolumn,
])
import natsort
postbl = postbl[natsort.index_natsorted(postbl['Source Name'])]
latexdict['header_start'] = '\label{tab:positions}'
latexdict['caption'] = 'Source Positions'
latexdict['tablefoot'] = ('\par\nObjects with name e\#d are the diffuse '
'counterparts to point sources. '
'The absolute positional accuracy is '
'$\sim0.2\\arcsec$. '
'Sources with no radius are unresolved, '
'with '
def make_tint_curves(mag=20, spec_res=100, sq_aper_diam=0.30, seeing_limited=False):
tint = np.arange(300, 3600+1, 300)
snr_y = np.zeros(len(tint), dtype=float)
snr_j = np.zeros(len(tint), dtype=float)
snr_h = np.zeros(len(tint), dtype=float)
snr_sum_y = np.zeros(len(tint), dtype=float)
snr_sum_j = np.zeros(len(tint), dtype=float)
snr_sum_h = np.zeros(len(tint), dtype=float)
spec_y_tab = None
spec_j_tab = None
spec_h_tab = None
for tt in range(len(tint)):
print 'Tint: ', tint[tt]
blah_y = etc_uh_roboAO(mag, 'Y', tint[tt],
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
blah_j = etc_uh_roboAO(mag, 'J', tint[tt],
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
blah_h = etc_uh_roboAO(mag, 'H', tint[tt],
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
col_y_suffix = '_Y_{0:d}'.format(tint[tt])
col_j_suffix = '_J_{0:d}'.format(tint[tt])
col_h_suffix = '_H_{0:d}'.format(tint[tt])
spec_signal_y = Column(name='sig'+col_y_suffix, data=blah_y[4])
spec_signal_j = Column(name='sig'+col_j_suffix, data=blah_j[4])
spec_signal_h = Column(name='sig'+col_h_suffix, data=blah_h[4])
spec_bkg_y = Column(name='bkg'+col_y_suffix, data=blah_y[5])
spec_bkg_j = Column(name='bkg'+col_j_suffix, data=blah_j[5])
spec_bkg_h = Column(name='bkg'+col_h_suffix, data=blah_h[5])
spec_snr_y = Column(name='snr'+col_y_suffix, data=blah_y[6])
spec_snr_j = Column(name='snr'+col_j_suffix, data=blah_j[6])
spec_snr_h = Column(name='snr'+col_h_suffix, data=blah_h[6])
if spec_y_tab == None:
spec_y_tab = Table([blah_y[3]], names=['wave_Y'])
if spec_j_tab == None:
spec_j_tab = Table([blah_j[3]], names=['wave_J'])
if spec_h_tab == None:
spec_h_tab = Table([blah_h[3]], names=['wave_H'])
spec_y_tab.add_columns([spec_signal_y, spec_bkg_y, spec_snr_y])
spec_j_tab.add_columns([spec_signal_j, spec_bkg_j, spec_snr_j])
spec_h_tab.add_columns([spec_signal_h, spec_bkg_h, spec_snr_h])
snr_y[tt] = blah_y[0]
snr_j[tt] = blah_j[0]
snr_h[tt] = blah_h[0]
snr_sum_y[tt] = math.sqrt((spec_snr_y**2).sum())
snr_sum_j[tt] = math.sqrt((spec_snr_j**2).sum())
snr_sum_h[tt] = math.sqrt((spec_snr_h**2).sum())
avg_tab = Table([tint,
snr_y, snr_sum_y,
snr_j, snr_sum_j,
snr_h, snr_sum_h],
names=['tint',
'snr_y', 'snr_sum_y',
'snr_j', 'snr_sum_j',
'snr_h', 'snr_sum_h'])
out_file = 'roboAO_tint_m{0:d}_R{1:d}_ap{2:0.3f}'.format(mag, spec_res, sq_aper_diam)
if seeing_limited:
out_file += '_seeing'
# Save the tables
spec_y_tab.write(out_file + '_spec_y_tab.fits', overwrite=True)
spec_j_tab.write(out_file + '_spec_j_tab.fits', overwrite=True)
spec_h_tab.write(out_file + '_spec_h_tab.fits', overwrite=True)
avg_tab.write(out_file + '_avg_tab.fits', overwrite=True)
return
#!/usr/bin/env python
import numpy as np
import sncosmo
from collections import OrderedDict as odict
from astropy.table import Table
model = sncosmo.Model(source='salt2')
model.set(z=0.5, c=0.2, t0=55100., x1=0.5)
model.set_source_peakabsmag(-19.5, 'bessellb', 'ab')
times = np.linspace(55070., 55150., 40)
bands = np.array(10 * ['sdssg', 'sdssr', 'sdssi', 'sdssz'])
zp = 25. * np.ones(40)
zpsys = np.array(40 * ['ab'])
flux = model.bandflux(bands, times, zp=zp, zpsys=zpsys)
fluxerr = (0.05 * np.max(flux)) * np.ones(40, dtype=float)
flux += fluxerr * np.random.randn(40)
data = Table(odict([('time', times), ('band', bands), ('flux', flux),
('fluxerr', fluxerr), ('zp', zp), ('zpsys', zpsys)]),
meta=dict(zip(model.param_names, model.parameters)))
sncosmo.write_lc(data, 'example_photometric_data.dat')
def run(photometry_table,
zcol,
data_file="cigale_in.fits",
config_file="pcigale.ini",
wait_for_input=False,
plot=True,
outdir='out',
compare_obs_model=False,
**kwargs):
"""
Input parameters and then run CIGALE.
Args:
photometry_table (astropy Table):
A table from some photometric catalog with magnitudes and
error measurements. Currently supports
DES, DECaLS, SDSS, Pan-STARRS and WISE
zcol (str):
Name of the column with redshift estimates.
data_file (str, optional):
Root name for the photometry data file generated used as input to CIGALE
config_file (str, optional):
Root name for the file where CIGALE's configuration is generated
wait_for_input (bool, optional):
If true, waits for the user to finish editing the auto-generated config file
before running.
plot (bool, optional):
Plots the best fit SED if true
cores (int, optional):
Number of CPU cores to be used. Defaults
to all cores on the system.
outdir (str, optional):
Path to the many outputs of CIGALE
If not supplied, the outputs will appear in a folder named out/
compare_obs_model (bool, optional):
If True compare the input observed fluxes with the model fluxes
This writes a Table to outdir named 'photo_observed_model.dat'
kwargs: These are passed into gen_cigale_in() and _initialise()
sed_modules (list of 'str', optional):
A list of SED modules to be used in the
PDF analysis. If this is being input, there
should be a corresponding correct dict
for sed_modules_params.
sed_module_params (dict, optional):
A dict containing parameter values for
the input SED modules. Better not use this
unless you know exactly what you're doing.
"""
gen_cigale_in(photometry_table,
zcol,
infile=data_file,
overwrite=True,
**kwargs)
_initialise(data_file, config_file=config_file, **kwargs)
if wait_for_input:
input("Edit the generated config file {:s} and press any key to run.".
format(config_file))
cigconf = Configuration(config_file)
analysis_module = get_module(cigconf.configuration['analysis_method'])
analysis_module.process(cigconf.configuration)
if plot:
try:
from pcigale_plots import sed # This modifies the backend to Agg so I hide it here
old_version = True
import pcigale
warnings.warn(
"You are using CIGALE version {:s}, for which support is deprecated. Please update to 2020.0 or higher."
.format(pcigale.__version__))
except ImportError:
from pcigale_plots.plot_types.sed import sed
old_version = False
if old_version:
sed(cigconf, "mJy", True)
else:
# TODO: Let the user customize the plot.
series = [
'stellar_attenuated', 'stellar_unattenuated', 'dust', 'agn',
'model'
]
sed(cigconf, "mJy", True, (False, 1e5), (False, 1e2), series,
"pdf", "out")
# Set back to a GUI
import matplotlib
matplotlib.use('TkAgg')
# Rename the default output directory?
if outdir != 'out':
try:
os.system("rm -rf {}".format(outdir))
os.system("mv out {:s}".format(outdir))
except:
print("Invalid output directory path. Output stored in out/")
# Move input files into outdir too
os.system("mv {:s} {:s}".format(data_file, outdir))
os.system("mv {:s} {:s}".format(config_file, outdir))
os.system("mv {:s}.spec {:s}".format(config_file, outdir))
# Compare?
if compare_obs_model:
#Generate an observation/model flux comparison table.
with Database() as base:
filters = OrderedDict([
(name, base.get_filter(name))
for name in cigconf.configuration['bands']
if not (name.endswith('_err') or name.startswith('line'))
])
filters_wl = np.array(
[filt.pivot_wavelength for filt in filters.values()])
mods = Table.read(outdir + '/results.fits')
try:
obs = Table.read(
os.path.join(outdir, cigconf.configuration['data_file']))
except:
print(
"Something went wrong here. Astropy was unable to read the observations table. Please ensure it is in the fits format."
)
return
for model, obj in zip(mods, obs):
photo_obs_model = Table()
photo_obs_model['lambda_filter'] = [
wl / 1000 for wl in filters_wl
]
photo_obs_model['model_flux'] = np.array(
[model["best." + filt] for filt in filters.keys()])
photo_obs_model['observed_flux'] = np.array(
[obj[filt] for filt in filters.keys()])
photo_obs_model['observed_flux_err'] = np.array(
[obj[filt + '_err'] for filt in filters.keys()])
photo_obs_model.write(outdir + "/photo_observed_model_" +
str(model['id']) + ".dat",
format="ascii",
overwrite=True)
#import pdb; pdb.set_trace()
return
gaussian = np.linspace(0, windowsize, windowsize + 1) # 2.718281828459045
gaussianF = np.power(
np.e, -np.power(gaussian - windowsize / 2, 2) / (2 * sigma * sigma))
gaussianF = gaussianF / np.sum(gaussianF)
postFlux = scipy.signal.convolve(p, gaussianF, 'same')
# plt.figure(1)
# plt.plot(gaussian,gaussianF,'-o')
# plt.show()
return postFlux
dir = './spec/PHOENIX-ACES-AGSS-COND-2011_Z-0.0/'
filename = 'lte02300-0.00-0.0.PHOENIX-ACES-AGSS-COND-2011-HiRes.fits'
hl = fits.open(dir + filename)
spec = Table(hl[1].data)
wave = spec['wave']
flux = spec['flux']
plt.figure(2)
plt1 = plt.plot(wave, flux, '-', label='origin')
flux1 = myConv(flux, 10)
plt2 = plt.plot(wave, flux1, '-', label='w = 10')
flux1 = myConv(flux, 50)
plt3 = plt.plot(wave, flux1, '-', label='w = 50')
plt.xlabel('wavelength')
plt.ylabel('flux')
plt.legend()
def rdz_flux_from_hdf_cubes(hdfcont,
minfrac=0.2,
maxfrac=2.0,
nperifu=1000,
add_flim=False,
sncut=6.0,
logspaced=False):
"""
Generate ra, dec, redshift and
flux from a sensivity cube, distribute
uniformly in x,y,z cube pixels
Parameters
----------
hdfcont : SensitivityCubeHDF5Container
sensitivity cubes for the shot to simulate
minfrac, maxfrac : float
the minimum and maximum fraction
of the flux limit used to define
a range of fluxes
nperifu : int (optional)
number of sources per IFU
sncut : float
the cut on SNR to pass to the flux
limits API if add_flim=True
"""
ra = []
dec = []
wave = []
flux = []
flims = []
ifuslots = []
tables = []
ifu_ra = []
ifu_dec = []
for ifuslot, scube in hdfcont.itercubes():
#if not "086" in ifuslot:
# continue
# Generate randoms in pixel space then transform
xsize = scube.sigmas.shape[2]
ysize = scube.sigmas.shape[1]
zsize = scube.sigmas.shape[0]
# Pixels centers start at 0.0 end at xsize - 1
x = uniform(-0.5, xsize + 0.5, size=nperifu)
y = uniform(-0.5, ysize + 0.5, size=nperifu)
# Not redshift!
z = uniform(0, zsize - 1, size=nperifu)
r, d, l = scube.wcs.all_pix2world(x, y, z, 0)
if add_flim:
flim = scube.get_f50(r, d, l, sncut)
flim[flim < 1e-30] = 100
flim[logical_not(isfinite(flim))] = 100
flims.extend(flim)
else:
# fixed value to generate fluxes around
flim = 5e-17
if logspaced:
logf = uniform(log10(flim * minfrac),
log10(flim * maxfrac),
size=nperifu)
f = power(10, logf)
else:
sqrtf = uniform(sqrt(flim * minfrac),
sqrt(flim * maxfrac),
size=nperifu)
f = square(sqrtf)
ra.extend(r)
dec.extend(d)
wave.extend(l)
flux.extend(f)
ifuslots.extend([ifuslot] * nperifu)
ifra, ifdec, l = scube.wcs.all_pix2world(xsize / 2 - 0.5,
ysize / 2. - 0.5, 0, 0)
ifu_ra.extend([ifra] * nperifu)
ifu_dec.extend([ifdec] * nperifu)
print("{:s} {:f} {:f}".format(ifuslot, ifra, ifdec))
table = Table(
[ra, dec, wave, flux, ifuslots, ifu_ra, ifu_dec],
names=["ra", "dec", "wave", "flux", "ifuslot", "ifu_ra", "ifu_dec"])
if add_flim:
table["flim"] = flim
print("Generated {:d} sources".format(len(ra)))
return table
def getdata(refcat, minra, redo=False, silent=False, logger=None):
"""
Get reference catalog information from DL database
Parameters
----------
cenra : float
Central RA for the search.
cendec : float
Central DEC for the search.
radius : float
Search radius in degrees.
refcat : table
Reference catalog name (e.g. 2MASS, Gaia, etc.)
version : str
Version of NSC reduction..
saveref : bool, optional
Save the output to SAVEFILE or a default filename. Default is False.
savefile : str, optional
The file to save to or search for existing catalog.
silent : bool, optional
Don't print anything to the screen.
logger : logging object, optional
Logging object to use for printing messages.
Returns
-------
ref : astropy table
Search results from the reference catalog.
Example
-------
cat = getrefcat(cenra,cendec,radius,refcat,file=file,saveref=saveref)
By D. Nidever Sep 2017
Translated to Python by D. Nidever, April 2022
"""
count = 0
t0 = time.time()
if logger is None:
logger = dln.basiclogger()
# Check that we have psql installed
out = subprocess.check_output(['which', 'psql'], shell=False)
if type(out) is bytes:
out = out.decode()
out = out.strip()
if dln.size(out) > 1:
out = out[0]
if os.path.exists(out) == 0:
raise ValueError('No PSQL found on this sytem.')
# Temporary directory
# /tmp is often small and get get fille dup
dldir, mssdir, localdir = utils.rootdirs()
# FLIP THIS AROUND, INPUT SHOULD BE THE "EASY" VERSION!!!
refname = str(refcat).upper()
if refname == 'II/312/AIS':
refname = 'GALEX'
elif refname == '2MASS-PSC':
refname = 'TMASS'
elif refname == '2MASS':
refname = 'TMASS'
elif refname == 'GAIA/GAIA':
refname = 'GAIA'
elif refname == 'Skymapper':
refname = 'SKYMAPPER'
elif refname == 'GLIMPSE':
catname = 'II/293/glimpse'
elif refname == 'SAGE':
catname = 'II/305/archive'
elif refname == 'ATLASREFCAT2':
refname = 'ATLAS'
ra0 = float(minra)
ra1 = minra + 1.0
outdir = '/net/dl1/users/dnidever/nsc/refcatalogs/' + refname + '/'
if os.path.exists(outdir) == False:
os.makedirs(outdir)
savefile = outdir + 'ref_%.6f_%.6f_%s.fits' % (ra0, ra1, refname)
if os.path.exists(os.path.abspath(os.path.dirname(savefile))) == False:
os.makedirs(os.path.abspath(os.path.dirname(savefile)))
if silent == False:
logger.info('Querying %s: %.6f <= RA < %.6f' % (refname, ra0, ra1))
# Loading previously loaded file
if os.path.exists(savefile) and redo == False:
logger.info(savefile + ' already exists and redo==False')
return None
# Do the Query
#--------------
else:
# Use DataLab database search
#----------------------------
if refname in [
'TMASS', 'GAIA', 'GAIADR2', 'GAIAEDR3', 'PS', 'SKYMAPPER',
'SKYMAPPERDR2', 'ALLWISE', 'ATLAS'
]:
if refname == 'TMASS':
tablename = 'twomass.psc'
cols = 'designation,ra as raj2000,dec as dej2000,j_m as jmag,j_cmsig as e_jmag,h_m as hmag,h_cmsig as e_hmag,k_m as kmag,k_cmsig as e_kmag,ph_qual as qflg'
##server = 'gp04.datalab.noao.edu'
#server = 'gp01.datalab.noirlab.edu'
##server = 'dldb1.sdm.noao.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
racol = 'ra'
deccol = 'dec'
if refname == 'GAIA':
tablename = 'gaia_dr1.gaia_source'
cols = 'source_id as source,ra as ra_icrs,ra_error as e_ra_icrs,dec as de_icrs,dec_error as e_de_icrs,'
cols += 'phot_g_mean_flux as fg,phot_g_mean_flux_error as e_fg,phot_g_mean_mag as gmag'
#server = 'gp04.datalab.noirlab.edu'
##server = 'gp01.datalab.noao.edu'
##server = 'dldb1.sdm.noao.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
if refname == 'GAIADR2':
tablename = 'gaia_dr2.gaia_source'
cols = 'source_id as source,ra,ra_error,dec,dec_error,pmra,pmra_error,pmdec,pmdec_error,phot_g_mean_flux as fg,phot_g_mean_flux_error as e_fg,'
cols += 'phot_g_mean_mag as gmag,phot_bp_mean_mag as bp,phot_bp_mean_flux as fbp,phot_bp_mean_flux_error as e_fbp,'
cols += 'phot_rp_mean_mag as rp,phot_rp_mean_flux as frp,phot_rp_mean_flux_error as e_frp'
#server = 'gp04.datalab.noirlab.edu'
##server = 'gp01.datalab.noao.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
if refname == 'GAIAEDR3':
tablename = 'gaia_edr3.gaia_source'
cols = 'source_id as source,ra,ra_error,dec,dec_error,pmra,pmra_error,pmdec,pmdec_error,phot_g_mean_flux as fg,phot_g_mean_flux_error as e_fg,'
cols += 'phot_g_mean_mag as gmag,phot_bp_mean_mag as bp,phot_bp_mean_flux as fbp,phot_bp_mean_flux_error as e_fbp,'
cols += 'phot_rp_mean_mag as rp,phot_rp_mean_flux as frp,phot_rp_mean_flux_error as e_frp'
#server = 'gp04.datalab.noirlab.edu'
##server = 'gp01.datalab.noao.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
if refname == 'PS':
#tablename = 'cp_calib.ps1'
tablename = 'public.ps1'
cols = 'ra, dec, g as gmag, r as rmag, i as imag, z as zmag, y as ymag'
##server = 'gp02.datalab.noirlab.edu'
#server = 'gp01.datalab.noirlab.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
if refname == 'SKYMAPPER':
tablename = 'skymapper_dr1.master'
cols = 'raj2000 as ra, dej2000 as dec, u_psf as sm_umag, e_u_psf as e_sm_umag, g_psf as sm_gmag, e_g_psf as e_sm_gmag, r_psf as sm_rmag,'
cols += 'e_r_psf as e_sm_rmag, i_psf as sm_imag,e_i_psf as e_sm_imag, z_psf as sm_zmag, e_z_psf as e_sm_zmag'
#server = 'gp04.datalab.noirlab.edu'
##server = 'gp01.datalab.noao.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
racol = 'raj2000'
deccol = 'dej2000'
if refname == 'SKYMAPPERDR2':
tablename = 'skymapper_dr2.master'
cols = 'raj2000 as ra, dej2000 as dec, u_psf as sm_umag, e_u_psf as e_sm_umag, g_psf as sm_gmag, e_g_psf as e_sm_gmag, r_psf as sm_rmag,'
cols += 'e_r_psf as e_sm_rmag, i_psf as sm_imag,e_i_psf as e_sm_imag, z_psf as sm_zmag, e_z_psf as e_sm_zmag'
#server = 'gp04.datalab.noirlab.edu'
##server = 'gp01.datalab.noao.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
racol = 'raj2000'
deccol = 'dej2000'
if refname == 'ALLWISE':
tablename = 'allwise.source'
#cols = 'ra, dec, w1mdef as w1mag, w1sigmdef as e_w1mag, w2mdef as w2mag, w2sigmdef as e_w2mag'
cols = 'ra, dec, w1mpro as w1mag, w1sigmpro as e_w1mag, w2mpro as w2mag, w2sigmpro as e_w2mag'
#server = 'gp04.datalab.noao.edu'
#server = 'gp01.datalab.noirlab.edu'
server = 'db02.datalab.noirlab.edu'
user = '******'
if refname == 'ATLAS':
tablename = 'atlasrefcat2'
cols = 'objid,ra,dec,plx as parallax,dplx as parallax_error,pmra,dpmra as pmra_error,pmdec,dpmdec as pmdec_error,gaia,dgaia as gaiaerr,'
cols += 'bp,dbp as bperr,rp,drp as rperr,teff,agaia,dupvar,ag,rp1,r1,r10,g as gmag,dg as gerr,gchi,gcontrib,'
cols += 'r as rmag, dr as rerr,rchi,rcontrib,i as imag,di as ierr,ichi,icontrib,z as zmag,dz as zerr,zchi,zcontrib,nstat,'
cols += 'j as jmag,dj as jerr,h as hmag,dh as herr,k as kmag,dk as kerr'
server = 'gp10.datalab.noirlab.edu'
user = '******'
# Use Postgres command with q3c cone search
refcattemp = savefile.replace('.fits', '.txt')
cmd = "psql -h " + server + " -U " + user + " -d tapdb -w --pset footer -c 'SELECT " + cols + " FROM " + tablename
if refname == 'SKYMAPPER' or refname == 'SKYMAPPERDR2':
cmd += " WHERE raj2000 >= %.6f and raj2000 < %.6f'" % (ra0,
ra1)
else:
cmd += " WHERE ra >= %.6f and ra < %.6f'" % (ra0, ra1)
cmd += " > " + refcattemp
dln.remove(refcattemp, allow=True)
dln.remove(savefile, allow=True)
out = subprocess.check_output(cmd, shell=True)
# Check for empty query
tlines = dln.readlines(refcattemp, nreadline=4)
if len(tlines) < 4:
if silent == False:
logger.info('No Results')
return []
# Load ASCII file and create the FITS file
ref = ascii.read(refcattemp, data_start=3, delimiter='|')
#ref = importascii(refcattemp,/header,delim='|',skipline=2,/silent)
dln.remove(refcattemp, allow=True)
# Fix 0.0 mags/errs in ATLAS
if refname == 'ATLAS':
magcols = [
'gaia', 'bp', 'rp', 'gmag', 'rmag', 'imag', 'zmag', 'jmag',
'hmag', 'kmag'
]
errcols = [
'gaiaerr', 'bperr', 'rperr', 'gerr', 'rerr', 'ierr',
'zerr', 'jerr', 'herr', 'kerr'
]
cols = ref.colnames
# Set mags with 0.0 to 99.99
for j in range(len(magcols)):
if magcols[j] in ref.colnames:
bdmag = (ref[magcols[j]] <= 0.0)
if np.sum(bdmag) > 0:
ref[magcols[j]][bdmag] = 99.99
# Set errors with 0.0 to 9.99
for j in range(len(errcols)):
if errcols[j] in ref.colnames:
bderr = (ref[errcols[j]] <= 0.0)
if np.sum(bderr) > 0:
ref[errcols[j]][bderr] = 9.99
# Use astroquery vizier
#----------------
# for low density with 2MASS/GAIA and always for GALEX and APASS
else:
# Use QUERYVIZIER for GALEX (python code has problems)
#if refname == 'II/312/ais' or refname == 'GALEX':
# if refcat eq 'APASS' then cfa=0 else cfa=1 ; cfa doesn't have APASS
#cfa = 1 # problems with CDS VizieR and cfa has APASS now
#if refcat == 'SAGE':
# cfa = 0
if refname.upper() == 'GALEX':
cols = [
'RAJ2000', 'DEJ2000', 'FUVmag', 'e_FUVmag', 'NUVmag',
'e_NUVmag'
]
catname = 'II/335/galex_ais'
elif refname.upper() == 'GLIMPSE':
# Only includes GLIMPSE I,II,3D
cols = [
'RAJ2000', 'DEJ2000', '_2MASS', '_3.6mag', 'e_3.6mag',
'_4.5mag', 'e_4.5mag'
]
catname = 'II/293/glimpse'
elif refname.upper() == 'SAGE':
cols = [
'RAJ2000', 'DEJ2000', '__3.6_', 'e__3.6_', '__4.5_',
'e__4.5_'
]
catname = 'II/305/catalog'
Vizier.ROW_LIMIT = -1
Vizier.TIMEOUT = 1000000
Vizier.columns = cols
result = Vizier.query_constraints(catalog=catname,
RA='>=' + str(ra0) + ' & <' +
str(ra1))
# Check for failure
if len(result) == 0:
if silent == False:
logger.info('Failure or No Results')
return []
ref = result[0]
ref.meta['description'] = ref.meta['description'][0:50]
#ref = QUERYVIZIER(refname,[cenra,cendec],radius*60,cfa=cfa,timeout=600,/silent)
# Fix/homogenize the GAIA tags
if refname == 'GAIA':
nref = len(ref)
orig = ref.copy()
dt = [('source', int), ('ra_icrs', float),
('e_ra_icrs', float), ('de_icrs', float),
('e_de_icrs', float), ('fg', float), ('e_fg', float),
('gmag', float)]
ref = np.zeros(nref, dtype=np.dtype(dt))
ref = Table(ref)
for n in orig.colnames:
ref[n] = orig[n]
ref['fg'] = orig['_fg_']
ref['e_fg'] = orig['e__fg_']
ref['gmag'] = orig['_gmag_']
del orig
# Fix/homogenize the 2MASS tags
elif refname == 'TMASS':
nref = len(ref)
orig = ref.copy()
dt = [('designation', (np.str, 50)), ('raj2000', float),
('dej2000', float), ('jmag', float), ('e_jmag', float),
('hmag', float), ('e_hmag', float), ('kmag', float),
('e_kmag', float), ('qflg', (np.str, 20))]
ref = np.zeros(nref, dtype=np.dtype(dt))
for n in orig.colnames:
ref[n] = orig[n]
ref['designation'] = orig['_2mass']
del orig
# Fix NANs in ALLWISE
elif refname == 'ALLWISE':
bd, = np.where(np.isfinite(ref['_3_6_']) == False)
if len(bd) > 0:
ref['_3_6_'][bd] = 99.99
ref['e__3_6_'][bd] = 9.99
bd, = np.where(np.isfinite(ref['_4_5_']) == False)
if len(bd) > 0:
ref['_4_5_'][bd] = 99.99
ref['e__4_5_'][bd] = 9.99
# Convert all mags and errmags to float32
for n in ref.colnames:
if n.find('mag') > -1:
ref[n] = ref[n].astype(np.float32)
if n.find('e_') > -1 and n.find('mag') > -1:
ref[n] = ref[n].astype(np.float32)
# Lowercase column names
for n in ref.colnames:
ref[n].name = n.lower()
# Convert raj2000/dej2000 to ra/dec
if 'raj2000' in ref.colnames:
ref['raj2000'].name = 'ra'
if 'dej2000' in ref.colnames:
ref['dej2000'].name = 'dec'
# Save the file
logger.info('Saving catalog to file ' + savefile)
ref.write(savefile, overwrite=True)
if silent == False:
logger.info('%d sources found dt=%.1f sec.' %
(len(ref), time.time() - t0))
return ref
def run_cigale(self,
data_file="cigale_in.fits",
config_file="pcigale.ini",
wait_for_input=False,
plot=True,
outdir='out',
compare_obs_model=False,
**kwargs):
"""
Generates the input data file for CIGALE
given the photometric points and redshift
of a galaxy
Args:
ID: str, optional
An ID for the galaxy. If none, "GalaxyA" is assigned.
data_file (str, optional):
Root name for the photometry data file generated used as input to CIGALE
config_file (str, optional):
Root name for the file where CIGALE's configuration is generated
wait_for_input (bool, optional):
If true, waits for the user to finish editing the auto-generated config file
before running.
plot (bool, optional):
Plots the best fit SED if true
cores (int, optional):
Number of CPU cores to be used. Defaults
to all cores on the system.
outdir (str, optional):
Path to the many outputs of CIGALE
If not supplied, the outputs will appear in a folder named out/
compare_obs_model (bool, optional):
If True compare the input observed fluxes with the model fluxes
This writes a Table to outdir named 'photo_observed_model.dat'
kwargs: These are passed into gen_cigale_in() and _initialise()
sed_modules (list of 'str', optional):
A list of SED modules to be used in the
PDF analysis. If this is being input, there
should be a corresponding correct dict
for sed_modules_params.
sed_module_params (dict, optional):
A dict containing parameter values for
the input SED modules. Better not use this
unless you know exactly what you're doing.
"""
# Adding import statement here in case CIGALE is
# not installed.
from .cigale import run
assert (len(self.photom) >
0), "No photometry found. CIGALE cannot be run."
assert (len(self.redshift) >
0), "No redshift found. CIGALE cannot be run"
new_photom = Table([self.photom])
new_photom['redshift'] = self.z
if self.name != '':
new_photom['ID'] = self.name
else:
new_photom['ID'] = 'FRBGalaxy'
run(new_photom, 'redshift', data_file, config_file, wait_for_input,
plot, outdir, compare_obs_model, **kwargs)
return
def main(args):
""" finds the best models of all standard stars in the frame
and normlize the model flux. Output is written to a file and will be called for calibration.
"""
log = get_logger()
log.info("mag delta %s = %f (for the pre-selection of stellar models)" %
(args.color, args.delta_color))
log.info('multiprocess parallelizing with {} processes'.format(args.ncpu))
# READ DATA
############################################
# First loop through and group by exposure and spectrograph
frames_by_expid = {}
for filename in args.frames:
log.info("reading %s" % filename)
frame = io.read_frame(filename)
expid = safe_read_key(frame.meta, "EXPID")
camera = safe_read_key(frame.meta, "CAMERA").strip().lower()
spec = camera[1]
uniq_key = (expid, spec)
if uniq_key in frames_by_expid.keys():
frames_by_expid[uniq_key][camera] = frame
else:
frames_by_expid[uniq_key] = {camera: frame}
frames = {}
flats = {}
skies = {}
spectrograph = None
starfibers = None
starindices = None
fibermap = None
# For each unique expid,spec pair, get the logical OR of the FIBERSTATUS for all
# cameras and then proceed with extracting the frame information
# once we modify the fibermap FIBERSTATUS
for (expid, spec), camdict in frames_by_expid.items():
fiberstatus = None
for frame in camdict.values():
if fiberstatus is None:
fiberstatus = frame.fibermap['FIBERSTATUS'].data.copy()
else:
fiberstatus |= frame.fibermap['FIBERSTATUS']
for camera, frame in camdict.items():
frame.fibermap['FIBERSTATUS'] |= fiberstatus
# Set fibermask flagged spectra to have 0 flux and variance
frame = get_fiberbitmasked_frame(frame,
bitmask='stdstars',
ivar_framemask=True)
frame_fibermap = frame.fibermap
frame_starindices = np.where(isStdStar(frame_fibermap))[0]
#- Confirm that all fluxes have entries but trust targeting bits
#- to get basic magnitude range correct
keep = np.ones(len(frame_starindices), dtype=bool)
for colname in ['FLUX_G', 'FLUX_R', 'FLUX_Z']: #- and W1 and W2?
keep &= frame_fibermap[colname][frame_starindices] > 10**(
(22.5 - 30) / 2.5)
keep &= frame_fibermap[colname][frame_starindices] < 10**(
(22.5 - 0) / 2.5)
frame_starindices = frame_starindices[keep]
if spectrograph is None:
spectrograph = frame.spectrograph
fibermap = frame_fibermap
starindices = frame_starindices
starfibers = fibermap["FIBER"][starindices]
elif spectrograph != frame.spectrograph:
log.error("incompatible spectrographs %d != %d" %
(spectrograph, frame.spectrograph))
raise ValueError("incompatible spectrographs %d != %d" %
(spectrograph, frame.spectrograph))
elif starindices.size != frame_starindices.size or np.sum(
starindices != frame_starindices) > 0:
log.error("incompatible fibermap")
raise ValueError("incompatible fibermap")
if not camera in frames:
frames[camera] = []
frames[camera].append(frame)
# possibly cleanup memory
del frames_by_expid
for filename in args.skymodels:
log.info("reading %s" % filename)
sky = io.read_sky(filename)
camera = safe_read_key(sky.header, "CAMERA").strip().lower()
if not camera in skies:
skies[camera] = []
skies[camera].append(sky)
for filename in args.fiberflats:
log.info("reading %s" % filename)
flat = io.read_fiberflat(filename)
camera = safe_read_key(flat.header, "CAMERA").strip().lower()
# NEED TO ADD MORE CHECKS
if camera in flats:
log.warning(
"cannot handle several flats of same camera (%s), will use only the first one"
% camera)
#raise ValueError("cannot handle several flats of same camera (%s)"%camera)
else:
flats[camera] = flat
if starindices.size == 0:
log.error("no STD star found in fibermap")
raise ValueError("no STD star found in fibermap")
log.info("found %d STD stars" % starindices.size)
log.warning("Not using flux errors for Standard Star fits!")
# DIVIDE FLAT AND SUBTRACT SKY , TRIM DATA
############################################
# since poping dict, we need to copy keys to iterate over to avoid
# RuntimeError due to changing dict
frame_cams = list(frames.keys())
for cam in frame_cams:
if not cam in skies:
log.warning("Missing sky for %s" % cam)
frames.pop(cam)
continue
if not cam in flats:
log.warning("Missing flat for %s" % cam)
frames.pop(cam)
continue
flat = flats[cam]
for frame, sky in zip(frames[cam], skies[cam]):
frame.flux = frame.flux[starindices]
frame.ivar = frame.ivar[starindices]
frame.ivar *= (frame.mask[starindices] == 0)
frame.ivar *= (sky.ivar[starindices] != 0)
frame.ivar *= (sky.mask[starindices] == 0)
frame.ivar *= (flat.ivar[starindices] != 0)
frame.ivar *= (flat.mask[starindices] == 0)
frame.flux *= (frame.ivar > 0) # just for clean plots
for star in range(frame.flux.shape[0]):
ok = np.where((frame.ivar[star] > 0)
& (flat.fiberflat[star] != 0))[0]
if ok.size > 0:
frame.flux[star] = frame.flux[star] / flat.fiberflat[
star] - sky.flux[star]
frame.resolution_data = frame.resolution_data[starindices]
# CHECK S/N
############################################
# for each band in 'brz', record quadratic sum of median S/N across wavelength
snr = dict()
for band in ['b', 'r', 'z']:
snr[band] = np.zeros(starindices.size)
for cam in frames:
band = cam[0].lower()
for frame in frames[cam]:
msnr = np.median(frame.flux * np.sqrt(frame.ivar) /
np.sqrt(np.gradient(frame.wave)),
axis=1) # median SNR per sqrt(A.)
msnr *= (msnr > 0)
snr[band] = np.sqrt(snr[band]**2 + msnr**2)
log.info("SNR(B) = {}".format(snr['b']))
###############################
max_number_of_stars = 50
min_blue_snr = 4.
###############################
indices = np.argsort(snr['b'])[::-1][:max_number_of_stars]
validstars = np.where(snr['b'][indices] > min_blue_snr)[0]
#- TODO: later we filter on models based upon color, thus throwing
#- away very blue stars for which we don't have good models.
log.info("Number of stars with median stacked blue S/N > {} /sqrt(A) = {}".
format(min_blue_snr, validstars.size))
if validstars.size == 0:
log.error("No valid star")
sys.exit(12)
validstars = indices[validstars]
for band in ['b', 'r', 'z']:
snr[band] = snr[band][validstars]
log.info("BLUE SNR of selected stars={}".format(snr['b']))
for cam in frames:
for frame in frames[cam]:
frame.flux = frame.flux[validstars]
frame.ivar = frame.ivar[validstars]
frame.resolution_data = frame.resolution_data[validstars]
starindices = starindices[validstars]
starfibers = starfibers[validstars]
nstars = starindices.size
fibermap = Table(fibermap[starindices])
# MASK OUT THROUGHPUT DIP REGION
############################################
mask_throughput_dip_region = True
if mask_throughput_dip_region:
wmin = 4300.
wmax = 4500.
log.warning(
"Masking out the wavelength region [{},{}]A in the standard star fit"
.format(wmin, wmax))
for cam in frames:
for frame in frames[cam]:
ii = np.where((frame.wave >= wmin) & (frame.wave <= wmax))[0]
if ii.size > 0:
frame.ivar[:, ii] = 0
# READ MODELS
############################################
log.info("reading star models in %s" % args.starmodels)
stdwave, stdflux, templateid, teff, logg, feh = io.read_stdstar_templates(
args.starmodels)
# COMPUTE MAGS OF MODELS FOR EACH STD STAR MAG
############################################
#- Support older fibermaps
if 'PHOTSYS' not in fibermap.colnames:
log.warning('Old fibermap format; using defaults for missing columns')
log.warning(" PHOTSYS = 'S'")
log.warning(" MW_TRANSMISSION_G/R/Z = 1.0")
log.warning(" EBV = 0.0")
fibermap['PHOTSYS'] = 'S'
fibermap['MW_TRANSMISSION_G'] = 1.0
fibermap['MW_TRANSMISSION_R'] = 1.0
fibermap['MW_TRANSMISSION_Z'] = 1.0
fibermap['EBV'] = 0.0
model_filters = dict()
for band in ["G", "R", "Z"]:
for photsys in np.unique(fibermap['PHOTSYS']):
model_filters[band + photsys] = load_legacy_survey_filter(
band=band, photsys=photsys)
log.info("computing model mags for %s" % sorted(model_filters.keys()))
model_mags = dict()
fluxunits = 1e-17 * units.erg / units.s / units.cm**2 / units.Angstrom
for filter_name, filter_response in model_filters.items():
model_mags[filter_name] = filter_response.get_ab_magnitude(
stdflux * fluxunits, stdwave)
log.info("done computing model mags")
# LOOP ON STARS TO FIND BEST MODEL
############################################
linear_coefficients = np.zeros((nstars, stdflux.shape[0]))
chi2dof = np.zeros((nstars))
redshift = np.zeros((nstars))
normflux = []
star_mags = dict()
star_unextincted_mags = dict()
for band in ['G', 'R', 'Z']:
star_mags[band] = 22.5 - 2.5 * np.log10(fibermap['FLUX_' + band])
star_unextincted_mags[band] = 22.5 - 2.5 * np.log10(
fibermap['FLUX_' + band] / fibermap['MW_TRANSMISSION_' + band])
star_colors = dict()
star_colors['G-R'] = star_mags['G'] - star_mags['R']
star_colors['R-Z'] = star_mags['R'] - star_mags['Z']
star_unextincted_colors = dict()
star_unextincted_colors[
'G-R'] = star_unextincted_mags['G'] - star_unextincted_mags['R']
star_unextincted_colors[
'R-Z'] = star_unextincted_mags['R'] - star_unextincted_mags['Z']
fitted_model_colors = np.zeros(nstars)
for star in range(nstars):
log.info("finding best model for observed star #%d" % star)
# np.array of wave,flux,ivar,resol
wave = {}
flux = {}
ivar = {}
resolution_data = {}
for camera in frames:
for i, frame in enumerate(frames[camera]):
identifier = "%s-%d" % (camera, i)
wave[identifier] = frame.wave
flux[identifier] = frame.flux[star]
ivar[identifier] = frame.ivar[star]
resolution_data[identifier] = frame.resolution_data[star]
# preselect models based on magnitudes
photsys = fibermap['PHOTSYS'][star]
if not args.color in ['G-R', 'R-Z']:
raise ValueError('Unknown color {}'.format(args.color))
bands = args.color.split("-")
model_colors = model_mags[bands[0] + photsys] - model_mags[bands[1] +
photsys]
color_diff = model_colors - star_unextincted_colors[args.color][star]
selection = np.abs(color_diff) < args.delta_color
if np.sum(selection) == 0:
log.warning("no model in the selected color range for this star")
continue
# smallest cube in parameter space including this selection (needed for interpolation)
new_selection = (teff >= np.min(teff[selection])) & (teff <= np.max(
teff[selection]))
new_selection &= (logg >= np.min(logg[selection])) & (logg <= np.max(
logg[selection]))
new_selection &= (feh >= np.min(feh[selection])) & (feh <= np.max(
feh[selection]))
selection = np.where(new_selection)[0]
log.info(
"star#%d fiber #%d, %s = %f, number of pre-selected models = %d/%d"
% (star, starfibers[star], args.color,
star_unextincted_colors[args.color][star], selection.size,
stdflux.shape[0]))
# Match unextincted standard stars to data
coefficients, redshift[star], chi2dof[star] = match_templates(
wave,
flux,
ivar,
resolution_data,
stdwave,
stdflux[selection],
teff[selection],
logg[selection],
feh[selection],
ncpu=args.ncpu,
z_max=args.z_max,
z_res=args.z_res,
template_error=args.template_error)
linear_coefficients[star, selection] = coefficients
log.info(
'Star Fiber: {}; TEFF: {:.3f}; LOGG: {:.3f}; FEH: {:.3f}; Redshift: {:g}; Chisq/dof: {:.3f}'
.format(starfibers[star], np.inner(teff,
linear_coefficients[star]),
np.inner(logg, linear_coefficients[star]),
np.inner(feh, linear_coefficients[star]), redshift[star],
chi2dof[star]))
# Apply redshift to original spectrum at full resolution
model = np.zeros(stdwave.size)
redshifted_stdwave = stdwave * (1 + redshift[star])
for i, c in enumerate(linear_coefficients[star]):
if c != 0:
model += c * np.interp(stdwave, redshifted_stdwave, stdflux[i])
# Apply dust extinction to the model
log.info("Applying MW dust extinction to star {} with EBV = {}".format(
star, fibermap['EBV'][star]))
model *= dust_transmission(stdwave, fibermap['EBV'][star])
# Compute final color of dust-extincted model
photsys = fibermap['PHOTSYS'][star]
if not args.color in ['G-R', 'R-Z']:
raise ValueError('Unknown color {}'.format(args.color))
bands = args.color.split("-")
model_mag1 = model_filters[bands[0] + photsys].get_ab_magnitude(
model * fluxunits, stdwave)
model_mag2 = model_filters[bands[1] + photsys].get_ab_magnitude(
model * fluxunits, stdwave)
fitted_model_colors[star] = model_mag1 - model_mag2
if bands[0] == "R":
model_magr = model_mag1
elif bands[1] == "R":
model_magr = model_mag2
#- TODO: move this back into normalize_templates, at the cost of
#- recalculating a model magnitude?
# Normalize the best model using reported magnitude
scalefac = 10**((model_magr - star_mags['R'][star]) / 2.5)
log.info('scaling R mag {:.3f} to {:.3f} using scale {}'.format(
model_magr, star_mags['R'][star], scalefac))
normflux.append(model * scalefac)
# Now write the normalized flux for all best models to a file
normflux = np.array(normflux)
fitted_stars = np.where(chi2dof != 0)[0]
if fitted_stars.size == 0:
log.error("No star has been fit.")
sys.exit(12)
data = {}
data['LOGG'] = linear_coefficients[fitted_stars, :].dot(logg)
data['TEFF'] = linear_coefficients[fitted_stars, :].dot(teff)
data['FEH'] = linear_coefficients[fitted_stars, :].dot(feh)
data['CHI2DOF'] = chi2dof[fitted_stars]
data['REDSHIFT'] = redshift[fitted_stars]
data['COEFF'] = linear_coefficients[fitted_stars, :]
data['DATA_%s' % args.color] = star_colors[args.color][fitted_stars]
data['MODEL_%s' % args.color] = fitted_model_colors[fitted_stars]
data['BLUE_SNR'] = snr['b'][fitted_stars]
data['RED_SNR'] = snr['r'][fitted_stars]
data['NIR_SNR'] = snr['z'][fitted_stars]
io.write_stdstar_models(args.outfile, normflux, stdwave,
starfibers[fitted_stars], data)
def initialize_object(cls,
input_samples,
Nsamples=1000,
twixie_flag=False):
"""
Read low latency posterior_samples
"""
names = ['weight', 'm1', 'm2', 'spin1', 'spin2', 'dist_mbta']
data_out = Table(input_samples, names=names)
data_out['mchirp'], data_out['eta'], data_out[
'q'] = lightcurve_utils.ms2mc(data_out['m1'], data_out['m2'])
data_out['chi_eff'] = ((data_out['m1'] * data_out['spin1'] +
data_out['m2'] * data_out['spin2']) /
(data_out['m1'] + data_out['m2']))
#modify 'weight' using twixie informations
if (twixie_flag):
twixie_file = "/home/reed.essick/mass-dip/production/O1O2-ALL_BandpassPowerLaw-MassDistBeta/twixie-sample-emcee_O1O2-ALL_MassDistBandpassPowerLaw1D-MassDistBeta2D_CLEAN.hdf5"
(data_twixie, logprob_twixie,
params_twixie), (massDist1D_twixie, massDist2D_twixie), (
ranges_twixie, fixed_twixie), (
posteriors_twixie,
injections_twixie) = backends.load_emcee_samples(
twixie_file, backends.DEFAULT_EMCEE_NAME)
nstp_twixie, nwlk_twixie, ndim_twixie = data_twixie.shape
num_1D_params_twixie = len(
distributions.KNOWN_MassDist1D[massDist1D_twixie]._params)
mass_model_twixie = distributions.KNOWN_MassDist1D[
massDist1D_twixie](
*data_twixie[0, 0, :num_1D_params_twixie]
) ### assumes 1D model params always come first, which should be OK
mass_model_twixie = distributions.KNOWN_MassDist2D[
massDist2D_twixie](mass_model_twixie,
*data_twixie[0, 0, num_1D_params_twixie:])
min_mass_twixie, max_mass_twixie = 1.0, 100.0
m_grid_twixie = np.linspace(min_mass_twixie, max_mass_twixie, 100)
ans_twixie = utils.qdist(data_twixie,
mass_model_twixie,
m_grid_twixie,
np.median(data_out['q']),
num_points=100)
ans_twixie = np.array([list(item) for item in ans_twixie])
twixie_func = interpolate.interp1d(ans_twixie[:, 0], ans_twixie[:,
1])
data_out['weight'] = data_out['weight'] * twixie_func(
data_out['q'])
data_out['weight'] = data_out['weight'] / np.max(data_out['weight'])
kernel = 1.0 * RationalQuadratic(length_scale=1.0, alpha=0.1)
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=0)
params = np.vstack((data_out['mchirp'], data_out['q'],
data_out['chi_eff'], data_out['dist_mbta'])).T
data = np.array(data_out['weight'])
gp.fit(params, data)
mchirp_min, mchirp_max = np.min(data_out['mchirp']), np.max(
data_out['mchirp'])
q_min, q_max = np.min(data_out['q']), np.max(data_out['q'])
chi_min, chi_max = np.min(data_out['chi_eff']), np.max(
data_out['chi_eff'])
dist_mbta_min, dist_mbta_max = np.min(data_out['dist_mbta']), np.max(
data_out['dist_mbta'])
cnt = 0
samples = []
while cnt < Nsamples:
mchirp = np.random.uniform(mchirp_min, mchirp_max)
q = np.random.uniform(q_min, q_max)
chi_eff = np.random.uniform(chi_min, chi_max)
dist_mbta = np.random.uniform(dist_mbta_min, dist_mbta_max)
samp = np.atleast_2d(np.array([mchirp, q, chi_eff, dist_mbta]))
weight = gp.predict(samp)[0]
thresh = np.random.uniform(0, 1)
if weight > thresh:
samples.append([mchirp, q, chi_eff, dist_mbta])
cnt = cnt + 1
samples = np.array(samples)
data_out = Table(data=samples,
names=['mchirp', 'q', 'chi_eff', 'dist_mbta'])
data_out["eta"] = lightcurve_utils.q2eta(data_out["q"])
data_out["m1"], data_out["m2"] = lightcurve_utils.mc2ms(
data_out["mchirp"], data_out["eta"])
data_out["q"] = 1.0 / data_out["q"]
return KNTable(data_out)
"mass_to_light_r" : mass_to_light["UGRIZ_K0"][:,2],
"mass_to_light_r_z0P1" : mass_to_light["UGRIZ_K0P1"][:,2],
"mass_to_light_i" : mass_to_light["UGRIZ_K0"][:,3],
"mass_to_light_i_z0P1" : mass_to_light["UGRIZ_K0P1"][:,3],
"mass_to_light_z" : mass_to_light["UGRIZ_K0"][:,4],
"mass_to_light_z_z0P1" : mass_to_light["UGRIZ_K0P1"][:,4],
"mass_to_light_U" : mass_to_light["UBVRI_K0"][:,0],
"mass_to_light_U_z0P1" : mass_to_light["UBVRI_K0P1"][:,0],
"mass_to_light_B" : mass_to_light["UBVRI_K0"][:,1],
"mass_to_light_B_z0P1" : mass_to_light["UBVRI_K0P1"][:,1],
"mass_to_light_V" : mass_to_light["UBVRI_K0"][:,2],
"mass_to_light_V_z0P1" : mass_to_light["UBVRI_K0P1"][:,2],
"mass_to_light_R" : mass_to_light["UBVRI_K0"][:,3],
"mass_to_light_R_z0P1" : mass_to_light["UBVRI_K0P1"][:,3],
"mass_to_light_I" : mass_to_light["UBVRI_K0"][:,4],
"mass_to_light_I_z0P1" : mass_to_light["UBVRI_K0P1"][:,4],
}
sdss_catalog = Table(sdss)
sdss_catalog_df = pd.DataFrame(sdss)
sdss_catalog_df.to_pickle("SDSS_matched_catalog")
#prop_sdss = make_prop_array(kcorrect,mass_to_light,np.size(vollim))
#np.save("prop_sdss", prop_sdss)
#import matplotlib.pyplot as plt
#plt.hist(dr8["AB_EXP"][:,2],bins=100,range=(0,1),alpha=0.5,density=True,label="SDSS b/a")
#plt.hist(dr8[vollim]["AB_EXP"][:,2],bins=100,range=(0,1),alpha=0.5,density=True,label="Vollim b/a")
#plt.xlabel("b/a")
#plt.legend()
#plt.show()
def test_compute_differential_flux_points(x_method, y_method):
"""Iterates through the 6 different combinations of input options.
Tests against analytical result or result from gammapy.spectrum.powerlaw.
"""
# Define the test cases for all possible options
energy_min = np.array([1.0, 10.0])
energy_max = np.array([10.0, 100.0])
spectral_index = 2.0
table = Table()
table['ENERGY_MIN'] = energy_min
table['ENERGY_MAX'] = energy_max
table['ENERGY'] = np.array([2.0, 20.0])
if x_method == 'log_center':
energy = np.sqrt(energy_min * energy_max)
elif x_method == 'table':
energy = table['ENERGY'].data
# Arbitrary model (simple exponential case)
def diff_flux_model(x):
return np.exp(x)
# Integral of model
def int_flux_model(E_min, E_max):
return np.exp(E_max) - np.exp(E_min)
if y_method == 'power_law':
if x_method == 'lafferty':
energy = _energy_lafferty_power_law(energy_min, energy_max,
spectral_index)
# Test that this is equal to analytically expected
# log center result
desired_energy = np.sqrt(energy_min * energy_max)
assert_allclose(energy, desired_energy, rtol=1e-6)
desired = power_law_evaluate(energy, 1, spectral_index, energy)
int_flux = power_law_integral_flux(desired, spectral_index, energy,
energy_min, energy_max)
elif y_method == 'model':
if x_method == 'lafferty':
energy = _x_lafferty(energy_min, energy_max, diff_flux_model)
desired = diff_flux_model(energy)
int_flux = int_flux_model(energy_min, energy_max)
int_flux_err = 0.1 * int_flux
table['INT_FLUX'] = int_flux
table['INT_FLUX_ERR_HI'] = int_flux_err
table['INT_FLUX_ERR_LO'] = -int_flux_err
result_table = compute_differential_flux_points(x_method, y_method, table,
diff_flux_model,
spectral_index)
# Test energy
actual_energy = result_table['ENERGY'].data
desired_energy = energy
assert_allclose(actual_energy, desired_energy, rtol=1e-3)
# Test flux
actual = result_table['DIFF_FLUX'].data
assert_allclose(actual, desired, rtol=1e-2)
# Test error
actual = result_table['DIFF_FLUX_ERR_HI'].data
desired = 0.1 * result_table['DIFF_FLUX'].data
assert_allclose(actual, desired, rtol=1e-3)
def build_table(self):
"""
Create a human readable table.
Returns
-------
`astropy.table.QTable`
"""
keywords = [
'Start Time', 'End Time', 'Source', 'Instrument', 'Type',
'Wavelength'
]
record_items = {}
for key in keywords:
record_items[key] = []
def validate_time(time):
# Handle if the time is None when coming back from VSO
if time is None:
return ['None']
if record.time.start is not None:
return [parse_time(time).strftime(TIME_FORMAT)]
else:
return ['N/A']
for record in self:
record_items['Start Time'] += validate_time(record.time.start)
record_items['End Time'] += validate_time(record.time.end)
record_items['Source'].append(str(record.source))
record_items['Instrument'].append(str(record.instrument))
if hasattr(record, 'extent') and record.extent is not None:
record_items['Type'].append(
str(record.extent.type) if record.extent.
type is not None else ['N/A'])
else:
record_items['Type'].append('N/A')
# If we have a start and end Wavelength, make a quantity
if hasattr(record,
'wave') and record.wave.wavemin and record.wave.wavemax:
unit = record.wave.waveunit
# Convert this so astropy units parses it correctly
if unit == "kev":
unit = "keV"
record_items['Wavelength'].append(
u.Quantity([
float(record.wave.wavemin),
float(record.wave.wavemax)
],
unit=unit))
# If not save None
else:
record_items['Wavelength'].append(None)
# If we have no wavelengths for the whole list, drop the col
if all([a is None for a in record_items['Wavelength']]):
record_items.pop('Wavelength')
keywords.remove('Wavelength')
else:
# Make whole column a quantity
try:
with u.set_enabled_equivalencies(u.spectral()):
record_items['Wavelength'] = u.Quantity(
record_items['Wavelength'])
# If we have mixed units or some Nones just represent as strings
except (u.UnitConversionError, TypeError):
record_items['Wavelength'] = [
str(a) for a in record_items['Wavelength']
]
return Table(record_items)[keywords]
def make_sensitivity_curves(tint=1200, spec_res=100, sq_aper_diam=0.30, seeing_limited=False):
mag = np.arange(10, 22)
snr_z = np.zeros(len(mag), dtype=float)
snr_y = np.zeros(len(mag), dtype=float)
snr_j = np.zeros(len(mag), dtype=float)
snr_h = np.zeros(len(mag), dtype=float)
snr_sum_z = np.zeros(len(mag), dtype=float)
snr_sum_y = np.zeros(len(mag), dtype=float)
snr_sum_j = np.zeros(len(mag), dtype=float)
snr_sum_h = np.zeros(len(mag), dtype=float)
bkg_z = np.zeros(len(mag), dtype=float)
bkg_y = np.zeros(len(mag), dtype=float)
bkg_j = np.zeros(len(mag), dtype=float)
bkg_h = np.zeros(len(mag), dtype=float)
star_z = np.zeros(len(mag), dtype=float)
star_y = np.zeros(len(mag), dtype=float)
star_j = np.zeros(len(mag), dtype=float)
star_h = np.zeros(len(mag), dtype=float)
spec_z_tab = None
spec_y_tab = None
spec_j_tab = None
spec_h_tab = None
# Calculate the number of supernovae.
N_SNe = 4500.0 * 0.6 * 10**(mag - 18.9)
out_file = 'roboAO_sensitivity_t{0:d}_R{1:d}_ap{2:0.3f}'.format(tint, spec_res,
sq_aper_diam)
# Save the output to a table.
_out = open(out_file + '.txt', 'w')
meta1 = '# tint = {0:5d}, R = {1:5d}, sq_ap_diam = {2:5.3f}"\n'
_out.write(meta1.format(tint, spec_res, sq_aper_diam))
_out.write('# Sensitivity integrated over broad band.')
hdr = '{0:5s} {1:6s} {2:5s} {3:5s} {4:5s} {5:5s} {6:5s} {7:5s}\n'
fmt = '{0:5.1f} {1:6.1f} {2:5.1f} {3:5.1f} {4:5.1f} {5:5.1f} {6:5.1f} {7:5.1f}\n'
_out.write(hdr.format('# Mag', 'N_SNe', 'J_SNR', 'H_SNR', 'J_ms', 'H_ms', 'J_mb', 'H_mb'))
for mm in range(len(mag)):
print 'Mag: ', mag[mm]
blah_z = etc_uh_roboAO(mag[mm], 'Z', tint,
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
blah_y = etc_uh_roboAO(mag[mm], 'Y', tint,
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
blah_j = etc_uh_roboAO(mag[mm], 'J', tint,
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
blah_h = etc_uh_roboAO(mag[mm], 'H', tint,
spec_res=spec_res, sq_aper_diam=sq_aper_diam,
seeing_limited=seeing_limited)
col_z_suffix = '_Z_{0:d}'.format(mag[mm])
col_y_suffix = '_Y_{0:d}'.format(mag[mm])
col_j_suffix = '_J_{0:d}'.format(mag[mm])
col_h_suffix = '_H_{0:d}'.format(mag[mm])
spec_signal_z = Column(name='sig'+col_z_suffix, data=blah_z[4])
spec_signal_y = Column(name='sig'+col_y_suffix, data=blah_y[4])
spec_signal_j = Column(name='sig'+col_j_suffix, data=blah_j[4])
spec_signal_h = Column(name='sig'+col_h_suffix, data=blah_h[4])
spec_bkg_z = Column(name='bkg'+col_z_suffix, data=blah_z[5])
spec_bkg_y = Column(name='bkg'+col_y_suffix, data=blah_y[5])
spec_bkg_j = Column(name='bkg'+col_j_suffix, data=blah_j[5])
spec_bkg_h = Column(name='bkg'+col_h_suffix, data=blah_h[5])
spec_snr_z = Column(name='snr'+col_z_suffix, data=blah_z[6])
spec_snr_y = Column(name='snr'+col_y_suffix, data=blah_y[6])
spec_snr_j = Column(name='snr'+col_j_suffix, data=blah_j[6])
spec_snr_h = Column(name='snr'+col_h_suffix, data=blah_h[6])
if spec_z_tab == None:
spec_z_tab = Table([blah_z[3]], names=['wave_Z'])
if spec_y_tab == None:
spec_y_tab = Table([blah_y[3]], names=['wave_Y'])
if spec_j_tab == None:
spec_j_tab = Table([blah_j[3]], names=['wave_J'])
if spec_h_tab == None:
spec_h_tab = Table([blah_h[3]], names=['wave_H'])
spec_z_tab.add_columns([spec_signal_z, spec_bkg_z, spec_snr_z])
spec_y_tab.add_columns([spec_signal_y, spec_bkg_y, spec_snr_y])
spec_j_tab.add_columns([spec_signal_j, spec_bkg_j, spec_snr_j])
spec_h_tab.add_columns([spec_signal_h, spec_bkg_h, spec_snr_h])
snr_z[mm] = blah_z[0]
snr_y[mm] = blah_y[0]
snr_j[mm] = blah_j[0]
snr_h[mm] = blah_h[0]
snr_sum_z[mm] = math.sqrt((spec_snr_z**2).sum())
snr_sum_y[mm] = math.sqrt((spec_snr_y**2).sum())
snr_sum_j[mm] = math.sqrt((spec_snr_j**2).sum())
snr_sum_h[mm] = math.sqrt((spec_snr_h**2).sum())
star_z[mm] = blah_z[1]
star_y[mm] = blah_y[1]
star_j[mm] = blah_j[1]
star_h[mm] = blah_h[1]
bkg_z[mm] = blah_z[2]
bkg_y[mm] = blah_y[2]
bkg_j[mm] = blah_j[2]
bkg_h[mm] = blah_h[2]
avg_tab = Table([mag, snr_z, snr_y, snr_j, snr_h,
snr_sum_z, snr_sum_y, snr_sum_j, snr_sum_h,
star_z, star_y, star_j, star_h, bkg_z, bkg_y, bkg_j, bkg_h],
names=['mag', 'snr_z', 'snr_y', 'snr_j', 'snr_h',
'snr_sum_z', 'snr_sum_y', 'snr_sum_j', 'snr_sum_h',
'star_z', 'star_y', 'star_j', 'star_h',
'bkg_z', 'bkg_y', 'bkg_j', 'bkg_h'])
out_file = 'roboAO_sensitivity_t{0:d}_R{1:d}_ap{2:0.3f}'.format(tint, spec_res, sq_aper_diam)
if seeing_limited:
out_file += '_seeing'
# Save the tables
spec_z_tab.write(out_file + '_spec_z_tab.fits', overwrite=True)
spec_y_tab.write(out_file + '_spec_y_tab.fits', overwrite=True)
spec_j_tab.write(out_file + '_spec_j_tab.fits', overwrite=True)
spec_h_tab.write(out_file + '_spec_h_tab.fits', overwrite=True)
avg_tab.write(out_file + '_avg_tab.fits', overwrite=True)
return
'22_briggs0': '2-2 Briggs 0',
'22_natural': '2-2 Natural',
'H77a': 'H$77\\alpha$ Briggs 0'
}
tbl = Table([
Column(data=[name_mapping[name] for name in cube_names], name="Cube ID"),
Column(data=([cubes[name].wcs.wcs.restfrq
for name in cube_names] * u.Hz).to(u.GHz),
name='Frequency'),
Column(data=[dv[name].to(u.km / u.s).value
for name in cube_names] * u.km / u.s,
name='Channel Width'),
Column(data=[errors[name].to(u.mJy).value
for name in cube_names] * u.mJy / u.beam,
name='RMS'),
Column(data=[beams[name].major.to(u.arcsec).value
for name in cube_names] * u.arcsec,
name='BMAJ'),
Column(data=[beams[name].minor.to(u.arcsec).value
for name in cube_names] * u.arcsec,
name='BMIN'),
Column(data=[beams[name].pa.to(u.deg).value
for name in cube_names] * u.deg,
name='BPA'),
])
tbl.add_column(
Column(data=[(1 * u.Jy).to(u.K,
u.brightness_temperature(
bm.sr,
freq * u.GHz,
def inspect_fits(parfile,output='FitInspection.pdf',vlim=[-300,300]*u.km/u.s, **kwargs):
'''
Produce pdf of fitting results for quality check.
Parameters
----------
parfile : str
Name of the parameter file in the joebvp format
output : str,optional
Name of file to write stackplots output
vlim : Quantity array, optional
Velocity range of stackplots
e.g.: [-400,
Returns
-------
'''
from joebvp import joebvpfit
from matplotlib.backends.backend_pdf import PdfPages
llist = LineList('ISM')
pp=PdfPages(output)
#import pdb;
#pdb.set_trace()
all=abslines_from_VPfile(parfile,linelist=llist,**kwargs) # Instantiate AbsLine objects and make list
acl=abscomponents_from_abslines(all,vtoler=15.) # Instantiate AbsComponent objects from this list
fitpars,fiterrors,parinfo,linecmts = joebvpfit.readpars(parfile)
fullmodel=makevoigt.cosvoigt(all[0].analy['spec'].wavelength.value,fitpars)
### Make a stackplot for each component
for comp in acl:
fig=comp.stack_plot(ymnx=(-0.1,1.3),show=False,return_fig=True,vlim=vlim, tight_layout=True)
if (len(comp._abslines)<6):
numrow = len(comp._abslines)%6
else:
numrow = 6
height = numrow*1.0+0.5
fig.set_figheight(height)
if len(comp._abslines)<6:
fig.set_figwidth(5.)
else:
fig.set_figwidth(10.)
stackaxes = fig.axes
for i,ax in enumerate(stackaxes):
line = comp._abslines[i]
thesepars=[[line.wrest.value],[line.attrib['logN']],[line.attrib['b'].value],
[line.z],[line.attrib['vel'].value],[line.limits.vlim[0].value],[line.limits.vlim[1].value]]
try:
thismodel=makevoigt.cosvoigt(line.analy['spec'].wavelength.value,thesepars)
except:
ax.text(-100,0.05,'These pixels not used to fit this line')
continue
axlin=ax.get_lines()
veldat=axlin[0].get_data()[0]
ax.plot(veldat,fullmodel,color='red',alpha=0.8)
ax.plot(veldat,thismodel,color='purple',linestyle='dashed')
botbuf = 0.5/height
fig.subplots_adjust(bottom=botbuf,left=0.1,right=0.95,hspace=0.,wspace=0.35)
title=comp.name
fig.suptitle(title)
fig.savefig(pp,format='pdf')
plt.close(fig)
### Write out full model fits file
normflux = line.analy['spec'].flux/line.analy['spec'].co
normsig = line.analy['spec'].sig / line.analy['spec'].co
modeltab = Table([line.analy['spec'].wavelength.value, fullmodel, normflux, normsig], names=['wavelength', 'model', 'normflux', 'normsig'])
# modeltab.write(outfile, format='fits', overwrite=True)
dummycont = np.ones(len(normflux))
spec = XSpectrum1D.from_tuple((modeltab['wavelength'], modeltab['model'], modeltab['normsig'], dummycont))
spec.write_to_fits(output[:-4]+'.fits')
pp.close()
def query_table(self, query={}, curation={}, selection={}, reorder_columns_rowidx=0,
add_coordinates=True, use_qtable=True):
"""
Get a formatted table of all query results. When multiple results are present for a single value, the best one
is picked unless the user specifies a selection. This functionality will be revisited in the future.
The output is as a QTable which allows Quantities to be embedded in the results.
Parameters
----------
query : dict
Query to use in MongoDB query language. Default is an empty dictionary for all results.
curation : dict or str
Name of file to use as curation for the data or dictionary with the field value and reference to use for
it (otherwise will pick best=1)
selection : dict
Dictionary of overwrites for the supplied curation
reorder_columns_rowidx : int or None
Row/entry index to use as a template for column order. If None, use
an undefined order (determined by `astropy.Table` initializer).
add_coordinates : bool or str
If True, adds a 'coord' column to the table (if it does not
exist) with a SkyCoord for this table. If 'raise', raises an
exception if this fails, otherwise a warning is generated.
use_qtable : bool
If True, the result is a QTable, otherwise, a Table
Returns
-------
df : astropy.table.QTable or astropy.table.Table
Astropy QTable of results
"""
results = self.query_db(query=query)
# Load curation file (JSON of best values to use)
curation_dict = _read_curation(curation)
# If user as provided any selection values, overwrite the curation settings
if selection:
curation_dict.update(selection)
# For each entry in result, select best field.value or what the user has specified
tab_data = []
for entry in results:
out_row = {}
for key, val in entry.items():
if not isinstance(val, (list, type(np.array([])))):
out_row[key] = val
else:
# Select best one to return
if len(val) > 1:
if key in curation_dict.keys():
# If selection listed a key, use the reference information there
ind = np.array([x['reference'] for x in val]) == curation_dict[key]
else:
ind = np.array([x.get('best', 0) for x in val]) == 1
# Only proceed if you have any results to consider
if len(val[ind]) > 0:
unit = val[ind][0].get('unit')
if val[ind][0].get('distribution') is not None:
temp_dic = _get_values_from_distribution(val[ind][0].get('distribution'))
temp_val = temp_dic['value']
else:
temp_val = val[ind][0]['value']
out_row[key] = self._store_quantity(temp_val, unit)
else:
unit = val[0].get('unit')
if val[0].get('distribution') is not None:
temp_dic = _get_values_from_distribution(val[0].get('distribution'))
temp_val = temp_dic['value']
else:
temp_val = val[0]['value']
out_row[key] = self._store_quantity(temp_val, unit)
tab_data.append(out_row)
if use_qtable:
tab = QTable(tab_data)
else:
tab = Table(tab_data)
if add_coordinates:
if 'coord' in tab.colnames:
warnings.warn('"coord" column already in database table, '
'not adding coordinates automatically')
else:
try:
coo = SkyCoord.guess_from_table(tab)
except Exception as e:
if add_coordinates == 'raise':
raise e
else:
warnings.warn(f'Failed to add coordinates - exception '
'raised in guess_from_table: {e}')
else:
tab['coord'] = coo
if reorder_columns_rowidx is None and len(tab_data) > 0:
return tab
elif len(tab_data) == 0:
return tab
else:
reorder_row_colnames = list(tab_data[reorder_columns_rowidx].keys())
for colname in tab.colnames:
if colname not in reorder_row_colnames:
reorder_row_colnames.append(colname)
return tab[reorder_row_colnames]
table = Table(
[
Tile, Number, RA, DEC, r_auto, g_auto, i_auto, z_auto, uJAVA_auto,
J0378_auto, J0395_auto, J0410_auto, J0430_auto, J0515_auto, J0660_auto,
J0861_auto, r_MAG_ISO_GAUSS, g_MAG_ISO_GAUSS, i_MAG_ISO_GAUSS,
z_MAG_ISO_GAUSS, uJAVA_MAG_ISO_GAUSS, J0378_MAG_ISO_GAUSS,
J0395_MAG_ISO_GAUSS, J0410_MAG_ISO_GAUSS, J0430_MAG_ISO_GAUSS,
J0515_MAG_ISO_GAUSS, J0660_MAG_ISO_GAUSS, J0861_MAG_ISO_GAUSS,
r_MAG_APER_6_0, g_MAG_APER_6_0, i_MAG_APER_6_0, z_MAG_APER_6_0,
uJAVA_MAG_APER_6_0, J0378_MAG_APER_6_0, J0395_MAG_APER_6_0,
J0410_MAG_APER_6_0, J0430_MAG_APER_6_0, J0515_MAG_APER_6_0,
J0660_MAG_APER_6_0, J0861_MAG_APER_6_0, r_auto_err, g_auto_err,
i_auto_err, z_auto_err, uJAVA_auto_err, J0378_auto_err, J0395_auto_err,
J0410_auto_err, J0430_auto_err, J0515_auto_err, J0660_auto_err,
J0861_auto_err, r_MAG_ISO_GAUSS_ERR, g_MAG_ISO_GAUSS_ERR,
i_MAG_ISO_GAUSS_ERR, z_MAG_ISO_GAUSS_ERR, J0378_MAG_ISO_GAUSS_ERR,
J0395_MAG_ISO_GAUSS_ERR, J0410_MAG_ISO_GAUSS_ERR,
J0430_MAG_ISO_GAUSS_ERR, J0515_MAG_ISO_GAUSS_ERR,
J0660_MAG_ISO_GAUSS_ERR, J0861_MAG_ISO_GAUSS_ERR, r_MAG_APER_6_0_err,
g_MAG_APER_6_0_err, i_MAG_APER_6_0_err, z_MAG_APER_6_0_err,
uJAVA_MAG_APER_6_0_err, J0378_MAG_APER_6_0_err, J0395_MAG_APER_6_0_err,
J0410_MAG_APER_6_0_err, J0430_MAG_APER_6_0_err, J0515_MAG_APER_6_0_err,
J0660_MAG_APER_6_0_err, J0861_MAG_APER_6_0_err
],
names=('Tile', 'Number', 'RA', 'Dec', 'rSDSS_auto', 'gSDSS_auto',
'iSDSS_auto', 'zSDSS_auto', 'uJAVA_auto', 'J0378_auto',
'J0395_auto', 'J0410_auto', 'J0430_auto', 'J0515_auto',
'J0660_auto', 'J0861_auto', 'rSDSS_ISO_GAUSS', 'gSDSS_ISO_GAUSS',
'iSDSS_ISO_GAUSS', 'zSDSS_ISO_GAUSS', 'uJAVA_ISO_GAUSS',
'J0378_ISO_GAUSS', 'J0395_ISO_GAUSS', 'J0410_ISO_GAUSS',
'J0430_ISO_GAUSS', 'J0515_ISO_GAUSS', 'J0660_ISO_GAUSS',
'J0861_ISO_GAUSS', 'rSDSS_MAG_APER_6_0', 'gSDSS_MAG_APER_6_0',
'iSDSS_MAG_APER_6_0', 'zSDSS_MAG_APER_6_0', 'uJAVA_MAG_APER_6_0',
'J0378_MAG_APER_6_0', 'J0395_MAG_APER_6_0', 'J0410_MAG_APER_6_0',
'J0430_MAG_APER_6_0', 'J0515_MAG_APER_6_0', 'J0660_MAG_APER_6_0',
'J0861_MAG_APER_6_0', 'rSDSS_auto_err', 'gSDSS_auto_err',
'iSDSS_auto_err', 'zSDSS_auto_err', 'uJAVA_auto_err',
'J0378_auto_err', 'J0395_auto_err', 'J0410_auto_err',
'J0430_auto_err', 'J0515_auto_err', 'J0660_auto_err',
'J0861_auto_err', 'rSDSS_ISO_GAUSS_err', 'gSDSS_ISO_GAUSS_err',
'iSDSS_ISO_GAUSS_err', 'zSDSS_ISO_GAUSS_err', 'J0378_ISO_GAUSS_err',
'J0395_ISO_GAUSS_err', 'J0410_ISO_GAUSS_err', 'J0430_ISO_GAUSS_err',
'J0515_ISO_GAUSS_err', 'J0660_ISO_GAUSS_err', 'J0861_ISO_GAUSS_err',
'rSDSS_MAG_APER_6_0_err', 'gSDSS_MAG_APER_6_0_err',
'iSDSS_MAG_APER_6_0_err', 'zSDSS_MAG_APER_6_0_err',
'uJAVA_MAG_APER_6_0_err', 'J0378_MAG_APER_6_0_err',
'J0395_MAG_APER_6_0_err', 'J0410_MAG_APER_6_0_err',
'J0430_MAG_APER_6_0_err', 'J0515_MAG_APER_6_0_err',
'J0660_MAG_APER_6_0_err', 'J0861_MAG_APER_6_0_err'),
meta={'name': 'first table'})
yref=src.galactic.b.value,
coordsys='GAL',
proj='TAN',
)
print(ref_image)
#list of detected sources
src_names = ["LMC N132D", "30 Dor C", "LHA 120-N 157B", "LMC P3"]
l = [280.31, 279.60, 279.55, 277.73] * u.deg
b = [-32.78, -31.91, -31.75, -32.09] * u.deg
radius = [0.2, 0.2, 0.5, 0.2] * u.deg
srctab = Table([src_names, l, b, radius],
names=("src_names", "longitude", "latitude", "radius"),
meta={'name': 'known source'})
off_regions = []
for s in srctab:
#circle=CircleSkyRegion(center=SkyCoord(s['longitude'], s['latitude'], unit='deg', frame='galactic'), radius=0.2*u.deg)
circle = CircleSkyRegion(center=SkyCoord(s['longitude'],
s['latitude'],
unit='deg',
frame='galactic'),
radius=s['radius'] * u.deg)
off_regions.append(circle)
exclusion_mask = ref_image.region_mask(off_regions[0])
exclusion_mask.data = 1 - exclusion_mask.data
def exptable_to_proctable(input_exptable, obstypes=None):
"""
Converts an exposure table to a processing table and an unprocessed table. The columns unique to a processing table
are filled with default values. If comments are made in COMMENTS or HEADERERR, those will be adjusted in the values
stored in the processing table.
Args:
input_exptable, Table. An exposure table. Each row will be converted to a row of an processing table. If
comments are made in COMMENTS or HEADERERR, those will be adjusted in the values
stored in the processing table.
obstypes, list or np.array. Optional. A list of exposure OBSTYPE's that should be processed (and therefore
added to the processing table).
Returns:
processing_table, Table. The output processing table. Each row corresponds with an exposure that should be
processed.
unprocessed_table, Table. The output unprocessed table. Each row is an exposure that should not be processed.
"""
log = get_logger()
exptable = input_exptable.copy()
if obstypes is None:
obstypes = default_exptypes_for_exptable()
## Define the column names for the exposure table and their respective datatypes
colnames, coldtypes, coldefaults = get_processing_table_column_defs(return_default_values=True)
# for col in ['COMMENTS']: #'HEADERERR',
# if col in exptable.colnames:
# for ii, arr in enumerate(exptable[col]):
# for item in arr:
# clean_item = item.strip(' \t')
# if len(clean_item) > 6:
# keyval = None
# for symb in [':', '=']:
# if symb in clean_item:
# keyval = [val.strip(' ') for val in clean_item.split(symb)]
# break
# if keyval is not None and len(keyval) == 2 and keyval[0].upper() in exptable.colnames:
# key, newval = keyval[0].upper(), keyval[1]
# expid, oldval = exptable['EXPID'][ii], exptable[key][ii]
# log.info(
# f'Found a requested correction to ExpID {expid}: Changing {key} val from {oldval} to {newval}')
# exptable[key][ii] = newval
good_exps = (exptable['EXPFLAG'] == 0)
good_types = np.array([val in obstypes for val in exptable['OBSTYPE']]).astype(bool)
good = (good_exps & good_types)
good_table = exptable[good]
unprocessed_table = exptable[~good]
## Remove columns that aren't relevant to processing, they will be added back in the production tables for
## end user viewing
for col in ['REQRA', 'REQDEC', 'TARGTRA', 'TARGTDEC', 'HEADERERR', 'COMMENTS', 'BADEXP']:
if col in exptable.colnames:
good_table.remove_column(col)
if len(good_table) > 0:
rows = []
for erow in good_table:
prow = erow_to_prow(erow)#, colnames, coldtypes, coldefaults)
rows.append(prow)
processing_table = Table(names=colnames, dtype=coldtypes, rows=rows)
else:
processing_table = Table(names=colnames, dtype=coldtypes)
return processing_table, unprocessed_table
from astropy.io import ascii
import astropy.coordinates as ac
from astropy.table import Table
# first export xlsx to csv
# remove some of header so only one line left above data
# read csv
tab = ascii.read('LWA352_tmp.csv', delimiter=',', data_start=1)
# parse values to WGS84
xx = []
yy = []
zz = []
names = []
for name, lat, lon in tab[['col2', 'col3', 'col4']]: # may need to adjust cols to use
print(name, lon, lat)
loc = ac.EarthLocation.from_geodetic(lon=lon, lat=lat) # default uses WGS84
xx.append(loc.x.value)
yy.append(loc.y.value)
zz.append(loc.z.value)
names.append(name)
# write out WGS84 values
tab = Table([xx, yy, zz, [0]*len(xx), names], names=['x', 'y', 'z', 'diam', 'name'])
tab.write('LWA352_tmp.cfg', format='ascii')
def save_table(self, table_type="csv", path=None, save_name=None):
'''
The results of the algorithm are saved as a csv after converting the data into a pandas dataframe.
Parameters
----------
table_type : str, optional
Sets the output type of the table. "csv" uses the pandas package.
"fits" uses astropy to output a FITS table.
path : str, optional
The path where the file should be saved.
save_name : str, optional
The prefix for the saved file. If None, the name from the header is used.
Returns
-------
self.dataframe : pandas dataframe
The dataframe is returned for use with the Analysis class.
'''
if save_name is None:
save_name = self.header["OBJECT"]
if not path:
if table_type=="csv":
filename = "".join([save_name,"_table",".csv"])
elif table_type=="fits":
filename = "".join([save_name,"_table",".fits"])
else:
if path[-1] != "/":
path = "".join(path,"/")
if table_type=="csv":
filename = "".join([save_name,"_table",".csv"])
elif table_type=="fits":
filename = "".join([save_name,"_table",".fits"])
data = {"Lengths" : self.lengths, \
"Menger Curvature" : self.menger_curvature,\
"Plane Orientation (RHT)" : self.rht_curvature["Mean"],\
"RHT Curvature" : self.rht_curvature["Std"],\
# "Estimated Width" : self.widths["Estimated Width"], \
"Branches" : self.branch_info["filament_branches"], \
"Branch Lengths" : self.branch_info["branch_lengths"]}
for i, param in enumerate(self.width_fits["Names"]):
data[param] = self.width_fits["Parameters"][:,i]
data[param+" Error"] = self.width_fits["Errors"][:,i]
if table_type=="csv":
from pandas import DataFrame, Series
for key in data.keys():
data[key] = Series(data[key])
df = DataFrame(data)
df.to_csv(filename)
elif table_type=="fits":
from astropy.table import Table
# Branch Lengths contains a list for each entry, which aren't accepted for BIN tables.
if "Branch Lengths" in data.keys():
del data["Branch Lengths"]
df = Table(data)
df.write(filename)
else:
raise NameError("Only formats supported are 'csv' and 'fits'.")
self.dataframe = df
return self
def read_samples(cls, filename_samples):
"""
Read LALinference posterior_samples
"""
import os
if not os.path.isfile(filename_samples):
raise ValueError("Sample file supplied does not exist")
if "hdf" in filename_samples:
samples_out = h5py.File(filename_samples, 'r')
samples_out = samples_out['lalinference']
data_out = Table(samples_out)
data_out['q'] = data_out['m1'] / data_out['m2']
data_out['mchirp'] = (data_out['m1'] * data_out['m2'])**(
3. / 5.) / (data_out['m1'] + data_out['m2'])**(1. / 5.)
data_out['theta'] = data_out['iota']
idx = np.where(data_out['theta'] > 90.)[0]
data_out['theta'][idx] = 180 - data_out['theta'][idx]
data_out["eta"] = lightcurve_utils.q2eta(data_out["q"])
data_out["m1"], data_out["m2"] = lightcurve_utils.mc2ms(
data_out["mchirp"], data_out["eta"])
data_out['q'] = 1.0 / data_out['q']
else:
data_out = Table.read(filename_samples, format='ascii')
if 'mass_1_source' in list(data_out.columns):
data_out['m1'] = data_out['mass_1_source']
print('setting m1 to m1_source')
if 'mass_2_source' in list(data_out.columns):
data_out['m2'] = data_out['mass_2_source']
print('setting m2 to m2_source')
if 'm1_detector_frame_Msun' in list(data_out.columns):
data_out['m1'] = data_out['m1_detector_frame_Msun']
print('setting m1 to m1_source')
if 'm2_detector_frame_Msun' in list(data_out.columns):
data_out['m2'] = data_out['m2_detector_frame_Msun']
print('setting m2 to m2_source')
if 'dlam_tilde' in list(data_out.columns):
data_out['dlambdat'] = data_out['dlam_tilde']
print('setting dlambdat to dlam_tilde')
if 'lam_tilde' in list(data_out.columns):
data_out['lambdat'] = data_out['lam_tilde']
print('setting lambdat to lam_tilde')
if 'delta_lambda_tilde' in list(data_out.columns):
data_out['dlambdat'] = data_out['delta_lambda_tilde']
print('setting dlambdat to delta_lambda_tilde')
if 'lambda_tilde' in list(data_out.columns):
data_out['lambdat'] = data_out['lambda_tilde']
print('setting lambdat to lambda_tilde')
if 'm1' not in list(data_out.columns):
eta = lightcurve_utils.q2eta(data_out['mass_ratio'])
m1, m2 = lightcurve_utils.mc2ms(data_out["chirp_mass"], eta)
data_out['m1'] = m1
data_out['m2'] = m2
data_out['mchirp'], data_out['eta'], data_out[
'q'] = lightcurve_utils.ms2mc(data_out['m1'], data_out['m2'])
data_out['q'] = 1.0 / data_out['q']
data_out['chi_eff'] = ((data_out['m1'] * data_out['spin1'] +
data_out['m2'] * data_out['spin2']) /
(data_out['m1'] + data_out['m2']))
data_out["dist"] = data_out["luminosity_distance_Mpc"]
return KNTable(data_out)
def tabulate_fit_results(data_iter,
band_names,
lambda_eff,
fit_func,
fitting_method='band',
config=None,
out_path=None):
"""Tabulate fit results for a collection of data tables
Results already written to out_path are skipped.
Args:
data_iter (iter): Iterable of photometric data for different SN
band_names (list): Name of bands included in ``data_iter``
lambda_eff (list): Effective wavelength for bands in ``band_names``
fit_func (func): Function to use to run fits
config (dict): Specifies priors / kwargs for fitting each model
out_path (str): Optionally cache results to file
Returns:
An astropy table with fit results
"""
# Set default kwargs
config = deepcopy(config) or dict()
fitting_func = _get_fitting_func(fitting_method, band_names, lambda_eff)
# Add meta_data to output table meta data
if Path(out_path).exists():
out_table = Table.read(out_path)
else:
out_table = Table(names=['obj_id', 'message'], dtype=['U20', 'U10000'])
out_table.meta['band_names'] = band_names
out_table.meta['lambda_eff'] = lambda_eff
out_table.meta['fit_func'] = fit_func.__name__
out_table.meta['out_path'] = str(out_path)
for data in data_iter:
# Get fitting priors and kwargs
obj_id = data.meta['obj_id']
if obj_id in out_table['obj_id']:
continue
salt2_prior, salt2_kwargs, sn91bg_prior, sn91bg_kwargs = \
utils.parse_config_dict(obj_id, config)
try:
fit_results = fitting_func(obj_id=obj_id,
data=data,
fit_func=fit_func,
priors_hs=salt2_prior,
priors_bg=sn91bg_prior,
kwargs_hs=salt2_kwargs,
kwargs_bg=sn91bg_kwargs)
out_table = vstack([out_table, fit_results])
except KeyboardInterrupt:
raise
except Exception as e:
out_table.add_row({
'obj_id': obj_id,
'message': str(e).replace('\n', '')
})
if out_path:
out_table.write(out_path)
return out_table
newfile = open('{0}_position.txt'.format(options.obsid),'w')
#################################################################################
# Setting initial parameters
#################################################################################
# Opening the metafits file:
metadata = fits.open('{0}.metafits'.format(options.obsid))[0].header
# Opening the model file:
header = fits.getheader("{0}-sources_comp.fits".format(options.obsid))
data = fits.getdata("{0}-sources_comp.fits".format(options.obsid))
# loading in the table data.
t = Table(data)
# Initialsing the RA, DEC and apparent flux vectors.
RA = np.array(t['ra'])
DEC = np.array(t['dec'])
App_int_flux = np.array(t['int_flux'])
err_App_int_flux = np.array(t['err_int_flux'])
# Initialising the user inputted pixel scale.
pix_scale = float(options.scale)
thresh_cond = 0.95
# RA and DEC of the pointing centre.
PC_RA = metadata['RA']
PC_DEC = metadata['DEC']
