More can be added as our programs evolve
There are a few parameters you should set beforehand.
plot_name is where the plot showing all composite spectra together will be saved.
title is the header on your plot
name_array is the list of legend labels
xmin and xmax define the boundary of the plot.
Plots actually defines which plots get shown
"""
queries = int(sys.argv[1])
d = {}
for n in range(queries):
if len(sys.argv) == queries + 3:
d["composite{0}".format(n + 1)] = composite.main(
sys.argv[n + 2], sys.argv[queries + 2])
if len(sys.argv) == queries + 4:
d["composite{0}".format(n + 1)] = composite.main(
sys.argv[n + 2], sys.argv[queries + 2], sys.argv[queries + 3])
if len(sys.argv) == queries + 5:
d["composite{0}".format(n + 1)] = composite.main(
sys.argv[n + 2], sys.argv[queries + 2], sys.argv[queries + 3],
sys.argv[queries + 4])
else:
d["composite{0}".format(n + 1)] = composite.main(sys.argv[n + 2])
#Read whatever you sasved the table as, iterates over however many composites you used.
#This is how you have to address things if you want to iterate over queries.
#The n+1 makes the first item composite1, not composite0.
for n in range(queries):
#d["data{0}".format(n+1)] = Table.read(d["composite{0}".format(n+1)].savedname, format='ascii')
plot_name is where the plot showing both composite spectra together will be saved.
wmin and wmax define the boundary of the plot.
"""
plot_name = '2_composite_comparison'
wmin = 4000
wmax = 7000
#This part works just fine
#composite_full = composite.main("SELECT * FROM Supernovae")
"""
Here we set the queries that get used to find the spectra for compositing.
We only want to select spectra that have data for both redshift and phase, so both of them need to be in the query.
But you can change the values to whatever you want.
"""
composite1 = composite.main("SELECT * FROM Supernovae WHERE Redshift >.01 AND Phase BETWEEN -3 AND 3")
composite2 = composite.main("SELECT * FROM Supernovae WHERE Redshift >.01 AND Phase BETWEEN 3 AND 7")
#This makes, shows, and saves a quick comparison plot...we can probably get rid of this when plotting.main works.
lowindex = np.where(composite1.wavelength == composite.find_nearest(composite1.wavelength, wmin))
highindex = np.where(composite1.wavelength == composite.find_nearest(composite1.wavelength, wmax))
plt.plot(composite1.wavelength[lowindex[0]:highindex[0]], composite1.flux[lowindex[0]:highindex[0]])
plt.plot(composite2.wavelength[lowindex[0]:highindex[0]], composite2.flux[lowindex[0]:highindex[0]])
plt.savefig('../plots/' + plot_name + '.png')
plt.show()
#Read whatever you sasved the table as
Data = Table.read(composite1.savedname, format='ascii')
#Checking to see how the table reads..right now it has a header that might be screwing things up.
print Data
import composite
import Plotting
from astropy.table import Table
import matplotlib.pyplot as plt
import numpy as np
import sys
composites = []
composites.append(
composite.main(
"SELECT * FROM Supernovae WHERE Morphology=5 AND PHASE BETWEEN .78 AND .80"
))
composites.append(
composite.main(
"SELECT * FROM Supernovae WHERE Morphology=5 AND PHASE BETWEEN .80 AND .82"
))
composites.append(
composite.main(
"SELECT * FROM Supernovae WHERE Morphology=5 AND PHASE BETWEEN .82 AND .85"
))
labels = ['Phase: .78 to .82', 'Phase: .82 to .85', 'Phase: .85 to .89']
scales = composite.find_scales(composites, composites[0].flux,
composites[0].ivar)
wmin = 0
wmax = 100000
for comp in composites:
SN = comp
if (SN.minwave > wmin):
def make_composite(query_strings,
boot=False,
nboots=100,
medmean=1,
selection='max_coverage',
gini_balance=False,
verbose=True,
make_corr=True,
av_corr=True,
multi_epoch=True,
combine=True,
low_av_test=None,
measure_vs=False,
get_og_arr=False,
shape_param=None,
db_file=None):
""" This is the main fuunction for constructing composite spectra from spectra stored in kaepora.
Args:
query_strings: A list of SQL query strings
Keyword Args:
boot: If 'b', estimate error via bootstrap resampling. If 'nb', create
composite spectrum without bootstrapping (faster).
medmean: If 1, do an inverse variance weighted average as a function
of wavelength. If 2, do a median.
selection: If multi_epoch is False, this string defines the selection
criteria for choosing a single spectrum from a SN. Options are:
'maximum_coverage'(default): largest wavelength range
'maximum_coverage_choose_uv': largest wavelength range but prioritize
hst and swift spectra
'choose_bluest': smallest minimum wavelength
'max_snr': highest signal to noise
'accurate_phase': closest to middle of the phase bin. TODO: implement
this without parsing the query (currently requires uncommenting
code)
'max_coverage_splice': allows multiple spectra from the same SN as
long as overlap is < 500 A
gini_balance: If True, finds region of the composite spectrum dominated
by high SNR spectra, then deweights these spectra to have the the
median weight in that wavelength range. TODO: improve this
algorithm (currently produced representative composites, but
deweighting straight to median might not be ideal). If False, ivar
spectra are left as is.
verbose: If True, print metadata of each spectrum object in SN_Array.
multi_epoch: If True, include all spectra for a given SN that satisify
the query. If False, choose one 1 spectrum per SN based on the
selection keyword.
combine: If True, combines spectra from the same SN with an inverse weighted
average prior to construction fo the composite spectrum. This should be
True if doing an inverse variance weighted average.
low_av_test: If True, does not correct SNe with A_V < low_av_test
measure_vs: If True, will measure and print the Si II 6355 line velocity and
error of each composite spectrum
og_arr: If True, this function will also return the original spectra in addition
to the new combined spectra of individual SNe.
Returns:
composites: Each element is a list of spectrum objects containing the composite spectrum.
sn_arrays: Each element is a list of the spectrum objects used to create the composite spectrum.
This includes pre-combined spectra but not necessarily every original spectrum.
(optional) og_sn_arrays: Each element is a list of the original spectrum objects used to make
the composite spectra (only if og_arr=True).
boot_sn_arrays: Each element is a list spectrum objects containing composite spectra generated
from the bootstrap resampling process.
"""
composites = []
sn_arrays = []
og_sn_arrays = []
boot_sn_arrays = []
store_boots = True
num_queries = len(query_strings)
for n in range(num_queries):
if get_og_arr:
comp, arr, og_arr, boots = composite.main(
query_strings[n],
boot=boot,
nboots=nboots,
medmean=medmean,
shape_param=shape_param,
selection=selection,
gini_balance=gini_balance,
combine=combine,
db_file=db_file,
make_corr=make_corr,
av_corr=av_corr,
verbose=verbose,
multi_epoch=multi_epoch,
low_av_test=low_av_test,
get_og_arr=get_og_arr)
og_sn_arrays.append(og_arr)
else:
comp, arr, boots = composite.main(query_strings[n],
boot=boot,
nboots=nboots,
medmean=medmean,
shape_param=shape_param,
selection=selection,
gini_balance=gini_balance,
combine=combine,
db_file=db_file,
make_corr=make_corr,
av_corr=av_corr,
verbose=verbose,
multi_epoch=multi_epoch,
low_av_test=low_av_test,
get_og_arr=get_og_arr)
if store_boots:
boot_sn_arrays.append(boots)
composites.append(comp)
sn_arrays.append(arr)
if None not in composites:
composite.optimize_scales(composites, composites[0], True)
composites = normalize_comps(composites)
if measure_vs:
for comp in composites:
dm15 = np.round(np.nanmean(comp.dm15_array[comp.x1:comp.x2]), 2)
# r = sa.measure_si_ratio(comp.wavelength[comp.x1:comp.x2], comp.flux[comp.x1:comp.x2], vexp = .001, dm15=dm15)
v_strong, si_min_wave = sa.measure_velocity(
comp.wavelength[comp.x1:comp.x2], comp.flux[comp.x1:comp.x2],
5900., 6300.)
print 'v = ', v_strong
for boot in boot_sn_arrays:
vs = []
for b in boot:
v_strong, si_min_wave = sa.measure_velocity(
b.wavelength[b.x1:b.x2], b.flux[b.x1:b.x2], 5900., 6300.)
vs.append(v_strong)
v_err = np.nanstd(vs)
print 'v_err = ', v_err
if get_og_arr:
return composites, sn_arrays, og_sn_arrays, boot_sn_arrays
else:
return composites, sn_arrays, boot_sn_arrays
boot = sys.argv[1]
if boot == 'nb':
boot = False
else:
boot = True
query_strings = sys.argv[2:]
num_queries = len(query_strings)
for n in range(num_queries):
c, sn_arr, boots = composite.main(query_strings[n],
boot,
nboots=100,
medmean=1,
gini_balance=True,
make_corr=False,
multi_epoch=True,
combine=True)
# c, sn_arr, boots = composite.main(query_strings[n], boot, medmean=1, gini_balance = False, multi_epoch=True, combine=False)
# composites.append(c)
# SN_Arrays.append(sn_arr)
# if store_boots:
# boot_sn_arrays.append(boots)
#use this for good composites
# c, sn_arr, boots = composite.main(query_strings[n], boot, medmean=1, gini_balance = True, verbose=True, multi_epoch=True, combine=True)
# composites.append(c)
# SN_Arrays.append(sn_arr)
# if store_boots:
# boot_sn_arrays.append(boots)
def main(queries, plot_name, plots, labels):
num = int(queries[1])
#Now the file name of the plot is labeled by time of creation, but you can personalize it if you want.
#Or rename it once it's been saved.
#plot_name = str(queries) + '_composite_comparison, ' + (time.strftime("%H,%M,%S"))
wmin = 3000
wmax = 10000
d = {}
for n in range(num):
if len(queries) == num + 3:
d["composite{0}".format(n + 1)] = composite.main(
queries[n + 2], queries[num + 2])
if len(queries) == num + 4:
d["composite{0}".format(n + 1)] = composite.main(
queries[n + 2], queries[num + 2], queries[num + 3])
if len(queries) == num + 5:
d["composite{0}".format(n + 1)] = composite.main(
queries[n + 2], queries[num + 2], queries[num + 3],
queries[num + 4])
else:
d["composite{0}".format(n + 1)] = composite.main(queries[n + 2])
#Read whatever you sasved the table as, iterates over however many composites you used.
#This is how you have to address things if you want to iterate over queries.
#The n+1 makes the first item composite1, not composite0.
for n in range(num):
d["data{0}".format(n + 1)] = Table.read(
d["composite{0}".format(n + 1)].savedname, format='ascii')
d["wavelengths{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Wavelength"]])
d["fluxes{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Flux"]])
d["variances{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Variance"]])
d["ages{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Age"]])
d["dm15s{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Dm_15"]])
d["vels{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Velocity"]])
d["reds{0}".format(n + 1)] = np.array(
[d["data{0}".format(n + 1)]["Redshift"]])
xmin = 0
xmax = 100000
for n in range(num):
wave = d["wavelengths{0}".format(n + 1)][0]
flux = d["fluxes{0}".format(n + 1)][0]
good = np.where(flux != 0)
lo_wave = wave[good][0]
hi_wave = wave[good][len(wave[good]) - 1]
print lo_wave, hi_wave
if (lo_wave > xmin):
xmin = lo_wave
if (hi_wave < xmax):
xmax = hi_wave
# From now on, list the data you want to plot as [ Xdata, Ydata, Xdata_2, Ydata_2]
#This chunk will create an array that's the right length for however many queries you used.
plot_array = []
name_array = []
residual_array = []
variance_array = []
age_array = []
dm15_array = []
vel_array = []
red_array = []
for n in range(num):
plot_array.append(d["wavelengths{0}".format(n + 1)])
plot_array.append(d["fluxes{0}".format(n + 1)])
residual_array.append(d["wavelengths{0}".format(n + 1)][0])
residual_list = np.array([d["fluxes{0}".format(n + 1)] - d["fluxes1"]])
residual_array.append(residual_list[0][0])
variance_array.append(d["wavelengths{0}".format(n + 1)][0])
variance_array.append(d["variances{0}".format(n + 1)][0])
age_array.append(d["wavelengths{0}".format(n + 1)][0])
age_array.append(d["ages{0}".format(n + 1)][0])
dm15_array.append(d["wavelengths{0}".format(n + 1)][0])
dm15_array.append(d["dm15s{0}".format(n + 1)][0])
vel_array.append(d["wavelengths{0}".format(n + 1)][0])
vel_array.append(d["vels{0}".format(n + 1)][0])
red_array.append(d["wavelengths{0}".format(n + 1)][0])
red_array.append(d["reds{0}".format(n + 1)][0])
name_array.append(labels[n])
name_array.append(" ")
#print variance_array # there were some problems with dimensionality, fixed now.
##################
#If you want to use custom names for your composites,
#fill out and uncomment this next line
#name_array = ["composite1name", " ", "composite2name", " ", etc]
##################
Relative_Flux = plot_array #plots all given composites
Variance = variance_array # Check it out! Variances plot now.
Residuals = residual_array # Check it out! Residuals plot now.
Spectra_Bin = []
Age = age_array
Delta = dm15_array
Redshift = red_array
## If you want custom names, uncomment and use line 83, for consistency.
##Otherwise it'll default to just labeling composites in order.
Names = name_array
Show_Data = [
Relative_Flux, Variance, Residuals, Spectra_Bin, Age, Delta, Redshift
]
## Available Plots: Relative Flux, Residuals, Spectra/Bin, Age, Delta, Redshift, Multiple Spectrum, Stacked Spectrum
## 0 1 2 3 4 5 6, 7
# the plots you want to create
# All of these worked for me. Test with your own queries. (Sam, 4/16)
# Choose the plot range and plot type!
Plots = plots
image_title = "../plots/" + plot_name + ".png"
title = plot_name
Plotting.main(Show_Data=Show_Data,
Plots=Plots,
image_title=image_title,
title=title,
Names=Names,
xmin=xmin,
xmax=xmax)