def calc_sfr(nsample=40000):
### setup SPS
run_params = model_setup.get_run_params(param_file=param_file)
sps = model_setup.load_sps(**run_params)
model = model_setup.load_model(**run_params)
obs = return_fake_obs({})
nbins = model.params['sfr_fraction'].shape[0]
#### create chain to sample from
flatchain = np.random.dirichlet(tuple(1.0 for x in xrange(6)),nsample)
flatchain = flatchain[:,:-1]
### define time array for SFHs
in_years = 10**model.params['agebins']/1e9
t = in_years.sum(axis=1)/2.
### output bins
sfr = np.zeros(shape=(t.shape[0],nsample))
#### sample the posterior
for jj in xrange(nsample):
if jj % 100 == 0:
print float(jj)/nsample
##### model call, to set parameters
thetas = flatchain[jj,:]
_,_,sm = model.mean_model(thetas, obs, sps=sps)
##### extract sfh parameters
# pass stellar mass to avoid extra model call
sfh_params = prosp_dutils.find_sfh_params(model,thetas,
obs,sps,sm=sm)
#### SFR
sfr[:,jj] = prosp_dutils.return_full_sfh(t, sfh_params,minsfr=-np.inf)
out = {}
out['sfr'] = sfr
out['flatchain'] = flatchain[:nsample,:]
out['model'] = model
return out
def cloudy_spectrum(ax):
from prospect.models import model_setup
param_file = '/Users/joel/code/python/prospector_alpha/parameter_files/brownseds_np/brownseds_np_params.py'
run_params = model_setup.get_run_params(param_file=param_file)
sps = model_setup.load_sps(**run_params)
model = model_setup.load_model(**run_params)
model.params['dust2'] = np.array(0.0)
obs = model_setup.load_obs(**run_params)
spec,_,_ = model.mean_model(model.initial_theta, obs, sps=sps)
model.params['add_neb_emission'] = np.array(False)
model.params['add_neb_continuum'] = np.array(False)
spec_neboff,_,_ = model.mean_model(model.initial_theta, obs, sps=sps)
spec_neb = (spec-spec_neboff)*3e18/sps.wavelengths**2
in_plot = (sps.wavelengths/1e4 > 6) & (sps.wavelengths/1e4 < 30)
spec_neb_smooth = smooth_spectrum(sps.wavelengths[in_plot], spec_neb[in_plot], 3500)
spec_neb_smooth *= 1e5 / spec_neb_smooth.max()
'''
neb_color = '0.7'
alpha = 0.7
ax.fill_between(sps.wavelengths[in_plot]/1e4, np.zeros_like(spec_neb_smooth), spec_neb_smooth,
color=neb_color,
alpha=alpha)
### label H2 + [ArII] (second is in cloudy but very small)
ax.fill_between([9.55,9.85],[0,0],[1,1],color=neb_color,alpha=alpha)
ax.fill_between([6.8,7.1],[0,0],[1,1],color=neb_color,alpha=alpha)
'''
lines = ['[ArII]',r'H$_2$','[SIV]','[NeIII]','[SIII]']
lam = [6.95,9.7,10.45,15.5,18.7]
# removed because they're too weak, just distracting
#lines = ['[ArIII]','[NeII]']
#lam = [9.0,12.8]
for ii in xrange(len(lines)):
ax.text(lam[ii]*1.008,0.14,lines[ii],
ha='left',fontsize=9.5)
for ii in xrange(len(lam)): ax.plot([lam[ii],lam[ii]],[0,1e5],linestyle='--',lw=1.5,color='k')
import numpy as np
import matplotlib.pyplot as plt
import spot_utils as pread
from prospect.io.read_results import results_from
from prospect.models import model_setup
paramfile = 'ad_params.py'
clargs = {'param_file': paramfile}
run_params = model_setup.get_run_params(argv=paramfile, **clargs)
print(run_params)
obs = model_setup.load_obs(**run_params)
sps = model_setup.load_sps(**run_params)
model = model_setup.load_model(**run_params)
wspec = sps.csp.wavelengths # *restframe* spectral wavelengths
a = 1.0 + model.params.get('zred', 0.6) # cosmological redshifting
wphot = np.array([f.wave_effective for f in obs['filters']])
# In [21]
# grab results, powell results, and our corresponding models
#res, pr, mod = results_from("{}_mcmc.h5".format(outroot))
res, pr, mod = results_from("demo_galphot_1508433060_mcmc.h5")
# In [22]
# To see how our MCMC samples look, we can examine a few traces
choice = np.random.choice
tracefig = pread.param_evol(res,
figsize=(20, 10),
chains=choice(128, size=10, replace=False))
import numpy as np
np.errstate(invalid='ignore')
from prospect.models import model_setup
from prospect.io import write_results
from prospect import fitting
from prospect.likelihood import lnlike_spec, lnlike_phot, write_log, chi_spec, chi_phot
# --------------
# Read command line arguments
# --------------
sargv = sys.argv
argdict = {'param_file': ''}
clargs = model_setup.parse_args(sargv, argdict=argdict)
run_params = model_setup.get_run_params(argv=sargv, **clargs)
# --------------
# Globals
# --------------
# SPS Model instance as global
sps = model_setup.load_sps(**run_params)
# GP instances as global
spec_noise, phot_noise = model_setup.load_gp(**run_params)
# Model as global
global_model = model_setup.load_model(**run_params)
# Obs as global
global_obs = model_setup.load_obs(**run_params)
# -----------------
# LnP function as global
##### modify nebon status
# we want to be able to turn it on and off at will
if sample_results['model'].params['add_neb_emission'] == 2:
sample_results['model'].params['add_neb_emission'] = np.array(True)
##### initialize sps
sps = model_setup.load_sps(**sample_results['run_params'])
###### MAXPROB_MODEL
# grab maximum probability, plus the thetas that gave it
maxprob = np.max(sample_results['lnprobability'])
probind = sample_results['lnprobability'] == maxprob
thetas = sample_results['chain'][probind,:]
if type(thetas[0]) != np.dtype('float64'):
thetas = thetas[0]
###### TEST LIKELIHOOD
run_params = model_setup.get_run_params(param_file=param_name)
gp_spec, gp_phot = model_setup.load_gp(**run_params)
likefn = LikelihoodFunction()
mu, phot, x = model.mean_model(model.initial_theta, sample_results['obs'], sps=sps)
mu, phot, x = model.mean_model(thetas, sample_results['obs'], sps = sps)
lnp_phot = likefn.lnlike_phot(phot, obs=sample_results['obs'], gp=gp_phot)
lnp_prior = model.prior_product(thetas)
print lnp_phot + lnp_prior
def post_processing(out_file, param_file, full_h5file=True, out_incl=False, **kwargs):
"""
Driver. Loads output, runs post-processing routine.
"""
# Dense, complex, terrible bookkeeping on my part here based on my naming system for prospector output files
obj = ''
field = ''
base = ''
count = 0
slash = 0
for i in kwargs['outname']:
if i == '/':
slash += 1
elif i == '_':
count += 1
elif out_incl:
if slash == 2 and count == 1:
obj += i
elif count == 2:
field += i
elif count == 3:
base += i
elif count == 4:
break
elif full_h5file:
if slash == 13 and count == 1:
obj += i
elif count == 2:
field += i
elif count == 3:
base += i
elif count == 4:
break
elif count == 0:
obj += i
elif count == 1:
field += i
elif count == 2:
base += i
elif count == 3 and not outy:
break
print(obj, field)
full_base = obj + '_' + field + '_' + base
img_base = 'img/' + full_base # /home/jonathan/img' +
print(full_base, img_base)
pkl = 'out.pkl'
res, pr, mod = bread.results_from(out_file)
print('bread')
# create flatchain, run post-processing!
res['flatchain'] = prosp_dutils.chop_chain(res['chain'], **res['run_params'])
res['flatprob'] = prosp_dutils.chop_chain(res['lnprobability'], **res['run_params'])
extra_output = calc_extra_quantities(res, **kwargs)
print('extra calculated')
print(base)
# choose correct folder where .h5 file is stored based on param file name
if base == 'corr':
folder = 'pkl_ecorr/' # 'pkl_ncorr/'
elif base == 'fico':
folder = 'pkl_efico/' # 'pkl_nfico/'
elif base == 'masstest':
folder = 'pkl_masstest/'
elif base == 'tt':
folder = 'pkl_tt/'
else:
folder = 'pkl_simsfh/'
'''
if base == 'thirty':
folder = 'etpkls/'
elif base == 'nth':
folder = 'ntpkls/'
elif base == 'fixedmet':
folder = 'pkls/'
elif base == 'otherbins':
folder = 'opkls/'
elif base == 'noelg':
folder = 'nmpkls/'
elif base == 'nother':
folder = 'nopkls/'
elif base == 'vary':
folder = 'ecorr_pkl/'
# folder = 'evar_pkl/'
elif base == 'noneb' or 'evarnoneb':
folder = 'nonebpkls/'
elif base == 'efifty2':
folder = 'efifty2_pkls/'
elif base == 'evar2':
folder = 'evar2_pkls/'
elif base == 'masstest':
folder = 'pkl_masstest'
'''
# folder = 'evar2_pkls/' # 'efifty2_pkls/'
# pkl extra output!
extra = folder + full_base + '_extra_' + pkl # full_base + '_extra_' + pkl
print(extra)
with open(extra, 'wb') as newfile: # 'wb' because binary format
pickle.dump(extra_output, newfile, pickle.HIGHEST_PROTOCOL)
print('extra pickled')
# PRINT TRACE SHOWING HOW ITERATIONS PROGRESS FOR EACH PARAMETER
# I edited param_evol to also store lnprob, but this is a silly and long-obsolete way of doing this
tracefig = bread.param_evol(res) # prints tracefig
plt.title(full_base) # BUCKET just added
# plt.savefig(img_base + '_tracefig.png', bbox_inches='tight')
# plt.show()
# FIND WALKER, ITERATION THAT GIVE MAX PROBABILITY
# a result of the silly, long-obsolete way I'm grabbing lnprob above
prob = res['lnprobability'][..., 0:]
print('max', prob.max())
row = prob.argmax() / len(prob[0])
col = prob.argmax() - row * len(prob[0])
walker, iteration = row, col
print(walker, iteration)
# PRINT CORNERFIG CONTOURS/HISTOGRAMS FOR EACH PARAMETER
bread.subtriangle(res, start=-1000, thin=5, show_titles=True)
plt.title(full_base) # BUCKET just added
# plt.savefig(img_base + '_cornerfig.png', bbox_inches='tight')
# plt.show()
# For FAST: truths=[mass, age, tau, dust2] (for 1824: [9.78, 0.25, -1., 0.00])
# We need the correct sps object to generate models
sargv = sys.argv
argdict = {'param_file': param_file}
clargs = model_setup.parse_args(sargv, argdict=argdict)
run_params = model_setup.get_run_params(argv=sargv, **clargs)
sps = model_setup.load_sps(**run_params)
print('sps')
# GET MODELED SPECTRA AND PHOTOMETRY
# These have the same shape as the obs['spectrum'] and obs['maggies'] arrays.
spec, phot, mfrac = mod.mean_model(res['chain'][walker, iteration, :], obs=res['obs'], sps=sps)
print('spec')
# PLOT SPECTRUM
wave = [f.wave_effective for f in res['obs']['filters']]
wave = np.asarray(wave)
# CHANGING OBSERVED TO REST FRAME WAVELENGTH
# grabbing data from catalogs
if field == 'cdfs':
datname = '/home/jonathan/cdfs/cdfs.v1.6.11.cat'
zname = '/home/jonathan/cdfs/cdfs.v1.6.9.awk.zout'
elif field == 'cosmos':
datname = '/home/jonathan/cosmos/cosmos.v1.3.8.cat' # main catalog
zname = '/home/jonathan/cosmos/cosmos.v1.3.6.awk.zout' # redshift catalog
elif field == 'uds':
datname = '/home/jonathan/uds/uds.v1.5.10.cat'
zname = '/home/jonathan/uds/uds.v1.5.8.awk.zout'
elif field == 'sim': # hacking for now
datname = '/home/jonathan/cosmos/cosmos.v1.3.8.cat' # main catalog
zname = '/home/jonathan/cosmos/cosmos.v1.3.6.awk.zout' # redshift catalog
# photometry catalog
with open(datname, 'r') as f:
hdr = f.readline().split()
dtype = np.dtype([(hdr[1], 'S20')] + [(n, np.float) for n in hdr[2:]])
dat = np.loadtxt(datname, comments='#', delimiter=' ', dtype=dtype)
# redshift catalog
with open(zname, 'r') as fz:
hdr_z = fz.readline().split()
dtype_z = np.dtype([(hdr_z[1], 'S20')] + [(n, np.float) for n in hdr_z[2:]])
zout = np.loadtxt(zname, comments='#', delimiter=' ', dtype=dtype_z)
# if z_spec exists, use it; else use best-fit z_phot
idx = dat['id'] == obj # array filled with: False for all dat['id'] != obj, True for dat['id'] == obj
zred = zout['z_spec'][idx][0]
if zred == -99:
zred = zout['z_peak'][idx][0]
print('redshift', zred)
# convert stored wavelengths to rest frame wavelengths
wave_rest = []
for j in range(len(wave)):
wave_rest.append(wave[j]/(1 + zred)) # 1 + z = l_obs / l_emit --> l_emit = l_obs / (1 + z)
wave_rest = np.asarray(wave_rest)
# OUTPUT SED results to pkls
full_base = folder + full_base
write_res = full_base + '_res_' + pkl # results
with open(write_res, 'wb') as newfile: # 'wb' because binary format
pickle.dump(res, newfile, pickle.HIGHEST_PROTOCOL) # res includes res['obs']['maggies'], ['maggies_unc'], etc.
write_sed = full_base + '_sed_' + pkl # model sed
with open(write_sed, 'wb') as newfile: # 'wb' because binary format
pickle.dump(phot, newfile, pickle.HIGHEST_PROTOCOL)
write_restwave = full_base + '_restwave_' + pkl # rest frame wavelengths
with open(write_restwave, 'wb') as newfile: # 'wb' because binary format
pickle.dump(wave_rest, newfile, pickle.HIGHEST_PROTOCOL)
write_spec = full_base + '_spec_' + pkl # spectrum
with open(write_spec, 'wb') as newfile: # 'wb' because binary format
pickle.dump(spec, newfile, pickle.HIGHEST_PROTOCOL)
write_sps = full_base + '_spswave_' + pkl # wavelengths that go with spectrum
with open(write_sps, 'wb') as newfile: # 'wb' because binary format
pickle.dump(sps.wavelengths, newfile, pickle.HIGHEST_PROTOCOL)
# OUTPUT chi_sq results to pkls
chi_sq = ((res['obs']['maggies'] - phot) / res['obs']['maggies_unc']) ** 2
write_chisq = full_base + '_chisq_' + pkl
with open(write_chisq, 'wb') as newfile: # 'wb' because binary format
pickle.dump(chi_sq, newfile, pickle.HIGHEST_PROTOCOL)
write_justchi = full_base + '_justchi_' + pkl
with open(write_justchi, 'wb') as newfile:
pickle.dump((res['obs']['maggies'] - phot) / res['obs']['maggies_unc'], newfile, pickle.HIGHEST_PROTOCOL)
# PLOT chi_sq
plt.plot(wave_rest, chi_sq, 'o', color='b')
plt.title(str(obj) + r' $\chi^2$')
plt.xlabel('Rest frame wavelength [angstroms]')
plt.ylabel(r'$\chi^2$')
# plt.savefig(img_base + '_chisq.png', bbox_inches='tight')
# plt.show()
# HOW CONVERGED IS THE CODE?? LET'S FIND OUT! --> kl test
parnames = np.array(res['model'].theta_labels())
fig, kl_ax = plt.subplots(1, 1, figsize=(7, 7))
for l in xrange(parnames.shape[0]):
kl_ax.plot(res['kl_iteration'], np.log10(res['kl_divergence'][:, l]), 'o', label=parnames[l], lw=1.5,
linestyle='-', alpha=0.6)
# OUTPUT kl test to pkls
write_klit = full_base + '_klit_' + pkl
with open(write_klit, 'wb') as newfile:
pickle.dump(res['kl_iteration'], newfile, pickle.HIGHEST_PROTOCOL)
write_kldvg = full_base + '_kldvg_' + pkl
with open(write_kldvg, 'wb') as newfile:
pickle.dump(res['kl_divergence'], newfile, pickle.HIGHEST_PROTOCOL)
kl_ax.set_ylabel('log(KL divergence)')
kl_ax.set_xlabel('iteration')
# kl_ax.set_xlim(0, nsteps*1.1)
kl_div_lim = res['run_params'].get('convergence_kl_threshold', 0.018)
kl_ax.axhline(np.log10(kl_div_lim), linestyle='--', color='red', lw=2, zorder=1)
kl_ax.legend(prop={'size': 5}, ncol=2, numpoints=1, markerscale=0.7)
plt.title(str(obj) + ' kl')
def ems(param_file, out_file, objname='21442', field='cdfs', enames=None):
res, pr, model = bread.results_from(out_file)
# get lnprob, based on bread.param_evol()
chain = res['chain'][..., 0:, :]
lnprob = res['lnprobability'][..., 0:]
# deal with single chain (i.e. nested sampling) results
if len(chain.shape) == 2:
lnprob = lnprob[None, ...]
# tracefig, prob = bread.param_evol(res) # store probability
# plt.show()
print('max', lnprob.max())
row = lnprob.argmax() / len(lnprob[0])
col = lnprob.argmax() - row * len(lnprob[0])
walker, iteration = row, col
print(walker, iteration)
# Get emission lines!
# We need the correct sps object to generate models
sargv = sys.argv
argdict = {'param_file': param_file}
clargs = model_setup.parse_args(sargv, argdict=argdict)
run_params = model_setup.get_run_params(argv=sargv, **clargs)
sps = model_setup.load_sps(**run_params)
print('sps')
# spec, mags, sm = model.mean_model(res['chain'][walker, iteration, :], obs=res['obs'], sps=sps) # spec [maggies/Hz]
print('mean model')
w = sps.wavelengths
### save redshift, lumdist
z = model.params.get('zred', np.array(0.0))
lumdist = model.params.get('lumdist', np.array(0.0))
nebinspec = model.params.get('nebemlineinspec', True)
model.params['zred'] = np.array(0.0)
if lumdist:
model.params['lumdist'] = np.array(1e-5)
if nebinspec == False:
model.params['nebemlineinspec'] = True
### if we want restframe optical photometry, generate fake obs file
### else generate NO obs file (don't do extra filter convolutions if not necessary)
obs = {'filters': [], 'wavelength': None}
### calculate SED. comes out as maggies per Hz, @ 10pc
spec, mags, sm = model.mean_model(res['chain'][walker, iteration, :],
obs=obs,
sps=sps) # maggies/Hz at 10pc
w = sps.wavelengths
### reset model
model.params['zred'] = z
if lumdist:
model.params['lumdist'] = lumdist
if nebinspec == False:
model.params['nebemlineinspec'] = False
spec *= dfactor_10pc / constants.L_sun.cgs.value * to_ergs # spec * cm^2 * (s/erg) * erg/maggies = s*cm^2 / Hz
# note erg = [g cm^2 / s^2]
# according to measure_restframe_properties(), above line converts to Lsun / Hz
to_flam = 3e18 / w**2 # for f_nu in erg s^-1 Hz^-1 cm^-2: to_flam [(Ang / s^-1) * (1 / Ang^2)]
spec_flam = spec * to_flam # erg cm^-2 s^-1 ang^-1
smooth_spec = smooth_spectrum(w, spec_flam, 250.0, minlam=3e3, maxlam=7e3)
### load fsps emission line list
loc = os.getenv('SPS_HOME') + '/data/emlines_info.dat'
dat = np.loadtxt(loc,
delimiter=',',
dtype={
'names': ('lam', 'name'),
'formats': ('f16', 'S40')
})
print('env')
print(type(enames))
### define emission lines
# legacy code compatible
if type(enames) == bool:
lines = np.array(
['Hdelta', 'Hbeta', '[OIII]1', '[OIII]2', 'Halpha', '[NII]'])
fsps_name = np.array([
'H delta 4102', 'H beta 4861', '[OIII]4960', '[OIII]5007',
'H alpha 6563', '[NII]6585'
])
else:
lines = enames
fsps_name = enames
print(lines, enames) # None, None
# lines = np.array(['Hdelta', 'Hbeta', '[OIII]1', '[OIII]2', 'Halpha', '[NII]'])
# fsps_name = np.array(['H delta 4102', 'H beta 4861', '[OIII]4960', '[OIII]5007', 'H alpha 6563', '[NII]6585'])
lines = np.array([
'[OII]1', '[OII]2', 'Hdelta', 'Hbeta', '[OIII]1', '[OIII]2', 'Halpha',
'[NII]'
])
fsps_name = np.array([
'[OII]3726', '[OII]3729', 'H delta 4102', 'H beta 4861', '[OIII]4960',
'[OIII]5007', 'H alpha 6563', '[NII]6585'
])
##### measure emission line flux + EQW
out = {}
# print(1, sps.emline_wavelengths) # big long array, 900 to 6*1e6
for jj in xrange(len(lines)):
# if we don't do nebular emission, zero this out
if not hasattr(sps, 'get_nebline_luminosity'):
print('hi')
out[lines[jj]] = {'flux': 0.0, 'eqw': 0.0}
continue
### calculate luminosity (in Lsun)
idx = fsps_name[jj] == dat['name']
# L_so = 3.84*10**33 erg/s
print(sps.params['mass'].sum())
eflux = float(sps.get_nebline_luminosity[idx] *
sps.params['mass'].sum()) # L_sun
elam = float(sps.emline_wavelengths[idx]) # Angstroms!
print(sps.get_nebline_luminosity[idx])
print(eflux, 'e luminosity') # typically 10**40 to 10**42
print(elam, 'elam') # Angstroms
# simple continuum estimation
tidx = np.abs(
sps.wavelengths - elam
) < 100 # True for sps.wavelengths within 100 Angstroms of elam wavelengths
eqw = eflux / np.median(
smooth_spec[tidx]
) # (erg/s) / (erg cm^-2 s^-1 Ang^-1) = Ang * cm**2
eflux *= 3.84 * 10**33 # erg/s (Lum, not flux)
out[lines[jj]] = {'flux': eflux, 'eqw': eqw}
return out, fsps_name
def make_all_plots(filebase=None,
extra_output=None,
outfolder=os.getenv('APPS')+'/prospector_alpha/plots/',
sample_results=None,
param_name=None,
plt_chain=True,
plt_corner=True,
plt_sed=True):
'''
Driver. Loads output, makes all plots for a given galaxy.
'''
# make sure the output folder exists
if not os.path.isdir(outfolder):
os.makedirs(outfolder)
if sample_results is None:
try:
sample_results, powell_results, model, extra_output = load_prospector_data(filebase, hdf5=True, load_extra_output=True)
except TypeError:
return
else: # if we already have sample results, but want powell results
try:
_, powell_results, model, extra_output = load_prospector_data(filebase,no_sample_results=True, hdf5=True)
except TypeError:
return
run_params = model_setup.get_run_params(param_file=param_name)
sps = model_setup.load_sps(**run_params)
# BEGIN PLOT ROUTINE
print 'MAKING PLOTS FOR ' + filebase.split('/')[-1] + ' in ' + outfolder
objname = sample_results['run_params'].get('objname','galaxy')
# chain plot
flatchain = prosp_dutils.chop_chain(sample_results['chain'],**sample_results['run_params'])
if plt_chain:
print 'MAKING CHAIN PLOT'
show_chain(sample_results,outname=outfolder+objname)
# corner plot
if plt_corner:
print 'MAKING CORNER PLOT'
subcorner(sample_results, sps, copy.deepcopy(sample_results['model']),
extra_output,flatchain,outname=outfolder+objname)
# sed plot
if plt_sed:
print 'MAKING SED PLOT'
# FAST fit?
try:
sample_results['run_params']['fastname']
fast=1
except:
fast=0
# plot
pfig = sed_figure(sresults = [sample_results], extra_output=[extra_output],
outname=outfolder+objname+'.sed.png')
def post_processing(out_file, param_file, out_incl=False, full_h5file=False): # , **kwargs):
"""
Driver. Loads output, runs post-processing routine.
"""
obj = ''
field = ''
base = ''
count = 0
slash = 0
for i in out_file:
if i == '/':
slash += 1
elif i == '_':
count += 1
elif out_incl:
if slash == 1 and count == 1:
obj += i
elif count == 2:
field += i
elif count == 3:
base += i
elif count == 4:
break
elif full_h5file:
if slash == 13 and count == 1: # slash=12
obj += i
elif count == 2:
field += i
elif count == 3:
base += i
elif count == 4:
break
elif count == 0:
obj += i
elif count == 1:
field += i
elif count == 2:
base += i
elif count == 3 and not outy:
break
print(field)
git = '/home/jonathan/.conda/envs/snowflakes/lib/python2.7/site-packages/prospector/git/'
full_base = 'pkl_tfn/' + obj + '_' + field + '_' + base # 'pkl_efastnoem/' # 'pkl_efico/'
pkl = 'out.pkl'
res, pr, mod = bread.results_from(out_file)
print('bread')
# create flatchain, run post-processing
res['flatchain'] = prosp_dutils.chop_chain(res['chain'], **res['run_params'])
res['flatprob'] = prosp_dutils.chop_chain(res['lnprobability'], **res['run_params'])
'''
extra_output = calc_extra_quantities(res) # , **kwargs)
print('extra calculated')
extra = full_base + '_extra_' + pkl
with open(extra, 'wb') as newfile: # 'wb' because binary format
pickle.dump(extra_output, newfile, pickle.HIGHEST_PROTOCOL)
print('extra pickled')
'''
prob = res['lnprobability'][:, 0:]
# PRINT TRACE SHOWING HOW ITERATIONS CONVERGE FOR EACH PARAMETER
# tracefig, prob = bread.param_evol(res) # print tracefig, store probability
# plt.title(full_base) # BUCKET just added
# plt.savefig('img/' + full_base + '_tracefig.png', bbox_inches='tight')
# plt.show()
# FIND WALKER, ITERATION THAT GIVE MAX PROBABILITY
print('max', prob.max())
row = prob.argmax() / len(prob[0])
col = prob.argmax() - row * len(prob[0])
walker, iteration = row, col
print(walker, iteration)
# PRINT CORNERFIG CONTOURS/HISTOGRAMS FOR EACH PARAMETER
'''
bread.subtriangle(res, start=0, thin=5, show_titles=True)
plt.title(full_base) # BUCKET just added
plt.savefig('img/' + full_base + '_cornerfig.png', bbox_inches='tight')
# plt.show()
'''
# For FAST: truths=[mass, age, tau, dust2] (for 1824: [9.78, 0.25, -1., 0.00])
# We need the correct sps object to generate models
sargv = sys.argv
argdict = {'param_file': param_file}
clargs = model_setup.parse_args(sargv, argdict=argdict)
run_params = model_setup.get_run_params(argv=sargv, **clargs)
sps = model_setup.load_sps(**run_params)
print('sps')
# GET MODELED SPECTRA AND PHOTOMETRY
# These have the same shape as the obs['spectrum'] and obs['maggies'] arrays.
spec, phot, mfrac = mod.mean_model(res['chain'][walker, iteration, :], obs=res['obs'], sps=sps)
print('spec')
# PLOT SPECTRUM
wave = [f.wave_effective for f in res['obs']['filters']]
wave = np.asarray(wave)
# CHANGING OBSERVED TO REST FRAME WAVELENGTH
if field == 'cdfs':
datname = '/home/jonathan/cdfs/cdfs.v1.6.11.cat'
zname = '/home/jonathan/cdfs/cdfs.v1.6.9.awk.zout'
elif field == 'cosmos':
datname = '/home/jonathan/cosmos/cosmos.v1.3.8.cat' # main catalog
zname = '/home/jonathan/cosmos/cosmos.v1.3.6.awk.zout' # redshift catalog
elif field == 'uds':
datname = '/home/jonathan/uds/uds.v1.5.10.cat'
zname = '/home/jonathan/uds/uds.v1.5.8.awk.zout'
with open(datname, 'r') as f:
hdr = f.readline().split()
dtype = np.dtype([(hdr[1], 'S20')] + [(n, np.float) for n in hdr[2:]])
dat = np.loadtxt(datname, comments='#', delimiter=' ', dtype=dtype)
with open(zname, 'r') as fz:
hdr_z = fz.readline().split()
dtype_z = np.dtype([(hdr_z[1], 'S20')] + [(n, np.float) for n in hdr_z[2:]])
zout = np.loadtxt(zname, comments='#', delimiter=' ', dtype=dtype_z)
idx = dat['id'] == obj # array filled: False when dat['id'] != obj, True when dat['id'] == obj
print(obj)
zred = zout['z_spec'][idx][0] # z = z_spec
if zred == -99:
zred = zout['z_peak'][idx][0] # if z_spec does not exist, z = z_phot
print('redshift', zred)
wave_rest = [] # REST FRAME WAVELENGTH
for j in range(len(wave)):
wave_rest.append(wave[j] / (1 + zred)) # 1 + z = l_obs / l_emit --> l_emit = l_obs / (1 + z)
wave_rest = np.asarray(wave_rest)
# OUTPUT SED results to files
write_res = full_base + '_res_' + pkl # results
with open(write_res, 'wb') as newfile: # 'wb' because binary format
pickle.dump(res, newfile, pickle.HIGHEST_PROTOCOL) # res includes res['obs']['maggies'] and ...['maggies_unc']
write_sed = full_base + '_sed_' + pkl # model sed
with open(write_sed, 'wb') as newfile: # 'wb' because binary format
pickle.dump(phot, newfile, pickle.HIGHEST_PROTOCOL)
write_restwave = full_base + '_restwave_' + pkl # rest frame wavelengths
with open(write_restwave, 'wb') as newfile: # 'wb' because binary format
pickle.dump(wave_rest, newfile, pickle.HIGHEST_PROTOCOL)
write_spec = full_base + '_spec_' + pkl # spectrum
with open(write_spec, 'wb') as newfile: # 'wb' because binary format
pickle.dump(spec, newfile, pickle.HIGHEST_PROTOCOL)
write_sps = full_base + '_spswave_' + pkl # wavelengths that go with spectrum
with open(write_sps, 'wb') as newfile: # 'wb' because binary format
try:
wlengths = sps.wavelengths
except AttributeError:
wlengths = sps.csp.wavelengths
pickle.dump(wlengths, newfile, pickle.HIGHEST_PROTOCOL)
# pickle.dump(sps.wavelengths, newfile, pickle.HIGHEST_PROTOCOL)
# OUTPUT CHI_SQ results to files
chi_sq = ((res['obs']['maggies'] - phot) / res['obs']['maggies_unc']) ** 2
write_chisq = full_base + '_chisq_' + pkl
with open(write_chisq, 'wb') as newfile: # 'wb' because binary format
pickle.dump(chi_sq, newfile, pickle.HIGHEST_PROTOCOL)
write_justchi = full_base + '_justchi_' + pkl
with open(write_justchi, 'wb') as newfile:
pickle.dump((res['obs']['maggies'] - phot) / res['obs']['maggies_unc'], newfile, pickle.HIGHEST_PROTOCOL)
# PLOT CHISQ
'''
plt.plot(wave_rest, chi_sq, 'o', color='b')
plt.title(str(obj) + r' $\chi^2$')
plt.xlabel('Rest frame wavelength [angstroms]')
plt.ylabel(r'$\chi^2$')
plt.savefig('img/' + full_base + '_chisq.png', bbox_inches='tight')
# plt.show()
'''
# HOW CONVERGED IS THE CODE?? LET'S FIND OUT!
'''
parnames = np.array(res['model'].theta_labels())
fig, kl_ax = plt.subplots(1, 1, figsize=(7, 7))
for l in xrange(parnames.shape[0]):
kl_ax.plot(res['kl_iteration'], np.log10(res['kl_divergence'][:, l]), 'o', label=parnames[l], lw=1.5,
linestyle='-', alpha=0.6)
'''
write_klit = full_base + '_klit_' + pkl
with open(write_klit, 'wb') as newfile:
pickle.dump(res['kl_iteration'], newfile, pickle.HIGHEST_PROTOCOL)
write_kldvg = full_base + '_kldvg_' + pkl
with open(write_kldvg, 'wb') as newfile:
pickle.dump(res['kl_divergence'], newfile, pickle.HIGHEST_PROTOCOL)
'''
def sed(objname, field, res, mod, walker, iteration, param_file, **kwargs):
# PRINT MODEL SED FOR GALAXY
# We need the correct sps object to generate models
sargv = sys.argv
argdict = {'param_file': param_file}
clargs = model_setup.parse_args(sargv, argdict=argdict)
run_params = model_setup.get_run_params(argv=sargv, **clargs)
sps = model_setup.load_sps(**run_params)
# GET MODELED SPECTRA AND PHOTOMETRY
# These have the same shape as the obs['spectrum'] and obs['maggies'] arrays.
spec, phot, mfrac = mod.mean_model(res['chain'][walker, iteration, :], obs=res['obs'], sps=sps)
mean = ((res['obs']['maggies']-phot)/res['obs']['maggies']).mean()
print(mean, 'mean') # print normalized mean difference between model and observations
# PLOT SPECTRUM
wave = [f.wave_effective for f in res['obs']['filters']]
wave = np.asarray(wave)
print('len', len(sps.wavelengths), len(spec))
''' #
plt.plot(sps.wavelengths, spec)
plt.xlabel('Wavelength [angstroms]')
plt.title(str(objname) + ' spec')
plt.show()
# ''' #
''' #
# HOW CONVERGED IS THE CODE?? LET'S FIND OUT!
parnames = np.array(res['model'].theta_labels())
fig, kl_ax = plt.subplots(1, 1, figsize=(7, 7))
for i in xrange(parnames.shape[0]):
kl_ax.plot(res['kl_iteration'], np.log10(res['kl_divergence'][:, i]),
'o', label=parnames[i], lw=1.5, linestyle='-', alpha=0.6)
kl_ax.set_ylabel('log(KL divergence)')
kl_ax.set_xlabel('iteration')
# kl_ax.set_xlim(0, nsteps*1.1)
kl_div_lim = res['run_params'].get('convergence_kl_threshold', 0.018)
kl_ax.axhline(np.log10(kl_div_lim), linestyle='--', color='red', lw=2, zorder=1)
kl_ax.legend(prop={'size': 5}, ncol=2, numpoints=1, markerscale=0.7)
plt.title(str(objname) + ' kl')
plt.show()
# ''' #
# field = kwargs['field']
# CHANGING OBSERVED TO REST FRAME WAVELENGTH
if field == 'cdfs':
datname = '/home/jonathan/cdfs/cdfs.v1.6.11.cat'
zname = '/home/jonathan/cdfs/cdfs.v1.6.9.awk.zout'
elif field == 'cosmos':
datname = '/home/jonathan/cosmos/cosmos.v1.3.8.cat' # main catalog
zname = '/home/jonathan/cosmos/cosmos.v1.3.6.awk.zout' # redshift catalog
elif field == 'uds':
datname = '/home/jonathan/uds/uds.v1.5.10.cat'
zname = '/home/jonathan/uds/uds.v1.5.8.zout'
with open(datname, 'r') as f:
hdr = f.readline().split()
dtype = np.dtype([(hdr[1], 'S20')] + [(n, np.float) for n in hdr[2:]])
dat = np.loadtxt(datname, comments='#', delimiter=' ', dtype=dtype)
with open(zname, 'r') as fz:
hdr_z = fz.readline().split()
dtype_z = np.dtype([(hdr_z[1], 'S20')] + [(n, np.float) for n in hdr_z[2:]])
zout = np.loadtxt(zname, comments='#', delimiter=' ', dtype=dtype_z)
idx = dat['id'] == objname # array filled: False when dat['id'] != objname, True when dat['id'] == objname
zred = zout['z_spec'][idx][0] # z = z_spec
if zred == -99:
zred = zout['z_peak'][idx][0] # if z_spec does not exist, z = z_phot
print(zred)
wave_rest = [] # REST FRAME WAVELENGTH
for i in range(len(wave)):
wave_rest.append(wave[i]/(1 + zred)) # 1 + z = l_obs / l_emit --> l_emit = l_obs / (1 + z)
# PLOT MODEL SED BEST FIT, INPUT PHOT
yerr = res['obs']['maggies_unc']
plt.subplot(111, xscale="log", yscale="log")
plt.errorbar(wave_rest, res['obs']['maggies'], yerr=yerr, marker='o', linestyle='', color='purple',
label='Observed photometry')
plt.plot(wave_rest, phot, 'D', label='Model', color='b', markerfacecolor='None', markersize=10,
markeredgewidth=1.25, markeredgecolor='k') # label='Model at {},{}'.format(walker, iteration)
plt.legend(loc="best", fontsize=20)
plt.title(str(field) + '-' + str(objname) + ' SED')
plt.plot(sps.wavelengths, spec, color='k', alpha=0.5)
plt.xlabel(r'Wavelength (Rest) [$\AA$]')
plt.ylabel('Maggies')
plt.xlim(10**3, 2.5*10**4)
plt.ylim(10**-5, 4*10**3)
plt.show()
# ''' #
# PLOT CHI_SQ BESTFIT
chi_sq = ((res['obs']['maggies'] - phot) / res['obs']['maggies_unc']) ** 2
plt.plot(wave_rest, chi_sq, 'o', color='b')
plt.title(str(objname) + r' $\chi^2$')
plt.xlabel('Rest frame wavelength [angstroms]')
plt.ylabel(r'$\chi^2$')
plt.show()
def compute_specmags(runname=None, outfolder=None):
'''
step 1: load observed spectra, model spectra, photometry
step 2: normalize model spectra to observed spectra (at red end, + blue if using u-band)
step 3: meld them together
step 4: calculate u, g, r mags from spectra
step 5: plot spectral u, g, r versus photometric u, g, r
dump into pickle file, call perform_wavelength_cal() to apply
future steps: don't use super low-res spectra
'''
print 'THIS FUNCTION IS BROKEN, UNTIL YOU LET THREED_DUTILS USE LUMDIST'
from bsfh import model_setup
if runname == None:
runname = 'brownseds'
#### load up prospector results
filebase, parm_basename, ancilname=prosp_dutils.generate_basenames(runname)
outname = os.getenv('APPS')+'/prospector_alpha/plots/'+runname+'/pcomp/sfrcomp.png'
alldata = prospector_io.load_alldata(runname=runname)
sps = prosp_dutils.setup_sps(custom_filter_key=None)
optphot = np.zeros(shape=(3,len(alldata)))
obsphot = np.zeros(shape=(3,len(alldata)))
for ii,dat in enumerate(alldata):
#### load up model spec
z = dat['residuals']['phot']['z']
mod_spec = dat['bfit']['spec']
mod_wav = sps.wavelengths
#### load up observed spec
# arrives in maggies * Hz
# change to maggies
spec_dict = prospector_io.load_spectra(dat['objname'])
opt_idx = spec_dict['source'] == 1
obs_wav = spec_dict['obs_lam'][opt_idx]
obs_spec = spec_dict['flux'][opt_idx] / (3e18 / obs_wav)
#### find adjoining sections in model
minwav = np.min(obs_wav)
maxwav = np.max(obs_wav)
lamlim = (2800,7500)
lower_join = (mod_wav > lamlim[0]) & (mod_wav < minwav)
upper_join = (mod_wav < lamlim[1]) & (mod_wav > maxwav)
#### normalize and combine
# take 300 angstrom slices on either side
dellam = 300
low_obs = obs_wav < minwav+dellam
low_mod = (mod_wav < minwav + dellam) & (mod_wav > minwav)
up_obs = obs_wav > maxwav-dellam
up_mod = (mod_wav > maxwav - dellam) & (mod_wav < maxwav)
# avoid known emission lines: [OII], [NII], Halpha, [SII]
elines = np.array([3727,6549,6563,6583,6717,6731])
lambuff = 22
for line in elines:
low_obs[(obs_wav > line - lambuff) & (obs_wav < line + lambuff)] = False
low_mod[(mod_wav > line - lambuff) & (mod_wav < line + lambuff)] = False
up_obs[(obs_wav > line - lambuff) & (obs_wav < line + lambuff)] = False
up_mod[(mod_wav > line - lambuff) & (mod_wav < line + lambuff)] = False
# calculate mean
lownorm = np.mean(obs_spec[low_obs]) / np.mean(mod_spec[low_mod])
upnorm = np.mean(obs_spec[up_obs]) / np.mean(mod_spec[up_mod])
# combine
comblam = np.concatenate((mod_wav[lower_join],obs_wav,mod_wav[upper_join]))
combspec = np.concatenate((mod_spec[lower_join]*lownorm,obs_spec,mod_spec[upper_join]*upnorm))
# plot conjoined spectra
if True:
# observed spectra
plt.plot(obs_wav,np.log10(obs_spec),color='black')
#plt.plot(obs_wav[up_obs],np.log10(obs_spec[up_obs]),color='purple')
#plt.plot(mod_wav[up_mod],np.log10(mod_spec[up_mod]),color='green')
# post-break model
plt.plot(mod_wav[lower_join],np.log10(mod_spec[lower_join]*lownorm),color='red')
plt.plot(mod_wav[upper_join],np.log10(mod_spec[upper_join]*upnorm),color='red')
plt.plot(mod_wav[lower_join],np.log10(mod_spec[lower_join]),color='grey')
plt.plot(mod_wav[upper_join],np.log10(mod_spec[upper_join]),color='grey')
# limits, save
plt.xlim(2800,7200)
plt.savefig('/Users/joel/code/python/prospector_alpha/plots/'+runname+'/pcomp/specnorm/'+dat['objname']+'.png',dpi=100)
plt.close()
#### convert combspec from maggies to Lsun/Hz
pc2cm = 3.08568E18
dfactor = (1+z) / ( 4.0 * np.pi * (dat['residuals']['phot']['lumdist']*1e6*pc2cm)**2)
combspec *= 3631*1e-23 / constants.L_sun.cgs.value / dfactor # to Jy, to erg/s/cm^2/Hz, to Lsun/cm^2/Hz, to Lsun/Hz
#### integrate spectra, save mags
optphot[0,ii],_ = prosp_dutils.integrate_mag(comblam,combspec,'SDSS Camera u',alt_file='/Users/joel/code/fsps/data/allfilters.dat',z=z)
optphot[1,ii],_ = prosp_dutils.integrate_mag(comblam,combspec,'SDSS Camera g',alt_file='/Users/joel/code/fsps/data/allfilters.dat',z=z)
optphot[2,ii],_ = prosp_dutils.integrate_mag(comblam,combspec,'SDSS Camera r',alt_file='/Users/joel/code/fsps/data/allfilters.dat',z=z)
optphot[:,ii] = 10**(-0.4*optphot[:,ii])
#### save observed mags
run_params = model_setup.get_run_params(param_file=parm_basename[ii])
obs = model_setup.load_obs(**run_params)
obsphot[0,ii] = obs['maggies'][obs['filters'] == 'SDSS_u']
obsphot[1,ii] = obs['maggies'][obs['filters'] == 'SDSS_g']
obsphot[2,ii] = obs['maggies'][obs['filters'] == 'SDSS_r']
##### plot
kwargs = {'color':'0.5','alpha':0.8,'histtype':'bar','lw':2,'normed':1,'range':(0.5,2.0)}
nbins = 80
x = obsphot / optphot
t**s = [r'(photometric flux / spectral flux) [u-band]',
r'(photometric flux / spectral flux) [g-band]',
r'(photometric flux / spectral flux) [r-band]']
#### ALL GALAXIES
fig, axes = plt.subplots(1, 3, figsize = (18.75,6))
for ii, ax in enumerate(axes):
num, b, p = ax.hist(x[ii,:],nbins,**kwargs)
save_xlim = ax.get_xlim()
b = (b[:-1] + b[1:])/2.
ax.set_ylabel('N')
ax.set_xlabel(t**s[ii])
ax.set_xlim(save_xlim)
ax.xaxis.set_major_locator(MaxNLocator(5))
plt.savefig('/Users/joel/code/python/prospector_alpha/plots/'+runname+'/pcomp/spectral_integration.png',dpi=dpi)
plt.close()
out = {'obs_phot':obsphot,'spec_phot':optphot}
prospector_io.save_spec_cal(out,runname=runname)
import numpy as np
import matplotlib.pyplot as pl
from matplotlib.ticker import MaxNLocator, NullLocator
from matplotlib.colors import LinearSegmentedColormap, colorConverter
from matplotlib.ticker import ScalarFormatter
#okay that is in, let's try this bullshit
## HERE IS A LIST OF THINGS THAT I REFUSE TO HARD CODE INTO THE PROGRAM!!!
#paramfile = '/Users/sgottlie/github/prospector/demo/demo_mock_params1.py'
paramfile = '/demo_mock_params1.py'
dmp1 = 'demo_mock_params1.py'
photfile = '/demo_photometry1.dat'
### OKAY ALL DONE
clargs = {'param_file': paramfile}
run_params = model_setup.get_run_params(argv=dmp1, **clargs)
print(run_params)
# load sps model (default)
sps = model_setup.load_sps(**run_params)
# load noise model (none)
spec_noise, phot_noise = model_setup.load_gp(**run_params)
# demo model
model = model_setup.load_model(**run_params)
# demo data (generated from the script)
obs = model_setup.load_obs(phottable=photfile, **run_params)
print('Mock S/N={}'.format(obs['mock_snr']))
if run_params['add_noise']:
def compare_sed():
### custom parameter file
### where mass is a six-parameter thing
param_file = 'brownseds_np_params.py'
run_params = model_setup.get_run_params(param_file=param_file)
sps = model_setup.load_sps(**run_params)
model = model_setup.load_model(**run_params)
obs = model_setup.load_obs(**run_params)
thetas = model.initial_theta
### create star formation history and metallicity history
mformed = 1e10
m_constant = return_declining_sfh(model,mformed, tau=1e12)
met = return_zt(model)
#met = np.ones_like(met)
thetas[model.theta_labels().index('logzsol')] = 0.0
### simple
i1, i2 = model.theta_index['mass']
thetas[i1:i2] = m_constant
nsamp = 21
met_comp = np.linspace(-1,0,nsamp)
spec, phot = [], []
for m in met_comp:
thetas[model.theta_labels().index('logzsol')] = m
specx, photx, x = model.mean_model(thetas, obs, sps=sps)
spec.append(specx)
phot.append(photx)
### complex
for i in xrange(met.shape[0]):
# zero out all masses
thetas[i1:i2] = np.zeros_like(m_constant)
# fill in masses and metallicities
thetas[model.theta_labels().index('logzsol')] = np.log10(met[i])
thetas[i1+i] = m_constant[i]
# generate spectrum, add to existing spectrum
sps.ssp.params.dirtiness = 1
specx, photx, x = model.mean_model(thetas, obs, sps=sps)
if i == 0:
spec_agez, phot_agez = specx, photx
else:
spec_agez += specx
phot_agez += photx
### plot
fig, ax = plt.subplots(1,1, figsize=(8, 7))
cmap = get_cmap(nsamp)
for i in xrange(0,nsamp,4): ax.plot(sps.wavelengths/1e4, np.log10(spec[i] / spec_agez),color=cmap(i), label=met_comp[i])
ax.axhline(0, linestyle='--', color='0.1')
ax.legend(loc=4,prop={'size':20},title=r'log(Z/Z$_{\odot}$) [fixed]')
ax.set_xlim(0.1,10)
ax.set_xscale('log',nonposx='clip',subsx=(2,5))
ax.xaxis.set_minor_formatter(minorFormatter)
ax.xaxis.set_major_formatter(majorFormatter)
ax.set_ylabel(r'log(f$_{\mathrm{Z}_{\mathrm{fixed}}}$ / f$_{\mathrm{Z(t)}}$)')
ax.set_xlabel('wavelength [microns]')
ax.set_ylim(-0.4,0.4)
plt.tight_layout()
plt.show()
print 1/0
import numpy as np
np.errstate(invalid='ignore')
from prospect.models import model_setup
from prospect.io import write_results
from prospect import fitting
from prospect.likelihood import lnlike_spec, lnlike_phot, write_log
# --------------
# Read command line arguments
# --------------
sargv = sys.argv
argdict = {'param_file': ''}
clargs = model_setup.parse_args(sargv, argdict=argdict)
run_params = model_setup.get_run_params(argv=sargv, **clargs)
# --------------
# Globals
# --------------
# SPS Model instance as global
sps = model_setup.load_sps(**run_params)
# GP instances as global
spec_noise, phot_noise = model_setup.load_gp(**run_params)
# Model as global
global_model = model_setup.load_model(**run_params)
# Obs as global
global_obs = model_setup.load_obs(**run_params)
# -----------------
# LnP function as global
def return_dat(runname, runname_comp, pltcorner=False, pltchain=False):
#filebase, pfile, ancilname = generate_basenames(runname)
#filebase2, pfile2, ancilname2 = generate_basenames(runname_comp)
size = 500000
filebase = ['/Users/joel/code/python/prospector_alpha/results/guillermo_nestle/guillermo_nestle']
pfile = ['/Users/joel/code/python/prospector_alpha/parameter_files/guillermo_nestle/guillermo_nestle_params.py']
filebase2 = ['/Users/joel/code/python/prospector_alpha/results/guillermo/guillermo']
pfile2 = ['/Users/joel/code/python/prospector_alpha/parameter_files/guillermo/guillermo_params.py']
#bad = ['NGC 0584','UGCA 166','Mrk 1450','UM 461','UGC 06850','NGC 4125','NGC 4551','Mrk 0475']
objname, hinformation, logz, logzerr, dlogz, ncall = [], [], [], [], [], []
for i, file in enumerate(filebase):
sresults, _, model, _ = load_prospector_data(file,load_extra_output=False)
### some of the nestle runs terminated due to time limit
### must regenerate the models
if model is None:
run_params = model_setup.get_run_params(param_file=pfile)
run_params['objname'] = file.split('_')[-1]
model = model_setup.load_model(**run_params)
sresults_mcmc, _, model_mcmc, _ = load_prospector_data(filebase2[i],load_extra_output=False)
flatchain = chop_chain(sresults_mcmc['chain'],**sresults_mcmc['run_params'])
flatchain, pnames_emcee = transform_chain(flatchain, model_mcmc)
### save some stuff
# logz_est.append(sresults['logvol'][sresults['lnprobability'].argmax()]+np.log10(np.exp(sresults['lnprobability'].max()))
npoints = sresults['run_params']['nestle_npoints']
logz_remain = np.max(sresults['lnprobability']) - (sresults['chain'].shape[0]/1000.)
dlogz.append(np.logaddexp(sresults['logz'], logz_remain) - sresults['logz'])
ncall.append(sresults['ncall'])
hinformation.append(sresults['h_information'][0])
logz.append(sresults['logz'][0])
logzerr.append(sresults['logzerr'][0])
sresults['dlogz'] = dlogz[-1]
### define output containers
if len(objname) == 0:
parnames = model.theta_labels()
mcmc, nestle = {}, {}
percs = ['q50','q84','q16','q2.5','q97.5',]
for dic in [mcmc, nestle]:
for par in parnames:
dic[par] = {}
for p in percs: dic[par][p] = []
dic['maxlnprob'] = []
### corner plot?
outname = file.split('results')[0]+'plots/'+runname+'/'+file.split('_')[-1]
if pltcorner:
# outname = outname+'.corner.png'
range = [tuple(np.percentile(flatchain[:,i],[1,99]).tolist()) for i in xrange(flatchain.shape[1])]
range = None
fig, nestle_pnames = ncorner(sresults, model, range=range)
ecorner(sresults_mcmc, flatchain, fig, pnames_emcee, outname+'.corner.png',n_pnames = nestle_pnames, range=range)
if pltchain:
plot_chain(sresults, parnames, outname+'.chain.png')
### load all data
for i,par in enumerate(parnames):
p1 = np.random.choice(sresults['chain'][:,i],size=size, p=sresults['weights'])
p2 = flatchain[:,i]
for dic, chain in zip([nestle,mcmc],[p1,p2]):
for q in dic[par].keys(): dic[par][q].append(np.percentile(chain, [float(q[1:])])[0])
nestle['maxlnprob'].append(sresults['lnprobability'].max())
mcmc['maxlnprob'].append(sresults_mcmc['lnprobability'].max())
objname.append(sresults['run_params'].get('objname','galaxy'))
print 1/0
dat = {'nestle': nestle, 'emcee': mcmc}
dat['labels'] = model.theta_labels()
dat['objname'] = objname
nestle_pars = {
'hinformation': hinformation,
'logz': logz,
'logzerr': logzerr,
'dlogz': dlogz,
'ncall': ncall
}
dat['nestle_pars'] = nestle_pars
return dat
#obs['filters'] = None # turn off filters for now, though should also check these!
# theta = np.array([10**10.7,11.02,0.23,0.57,0.99,1.57,0.02,-1.96,0.1,0.16,0.16,2.18])
theta = np.array([10**10.7,11.02,0.23,0.57,0.8,0.0,0.02,-1.96,0.1,0.16,0.16,2.18])
spec, phot, x = model.mean_model(theta, obs, sps=sps)
w = sps.wavelengths
print 'generated OLD prospector file!'
param_dict = {}
for k, v in sps.params.iteritems(): param_dict[k] = v
print param_dict
'''
from prospect.models import model_setup
outname = 'new_brownseds.pickle'
run_params = model_setup.get_run_params(param_file='new_brownseds.py')
sps = model_setup.load_sps(**run_params)
model = model_setup.load_model(**run_params)
obs = model_setup.load_obs(**run_params)
#model.params['zred']=np.atleast_1d(0.0)
#obs['filters'] = np.array([]) # turn off filters for now, though should also check these!
# theta = np.array([10**10.7,11.02,0.23,0.57,0.99,1.57,0.02,-1.96,0.1,0.16,0.16,2.18])
theta = np.array([10.7,11.02,0.23,0.57,0.8,0.0,0.02,-1.96,0.1,0.16,0.16,2.18])
spec, phot, x = model.mean_model(theta, obs, sps=sps)
w = sps.csp.wavelengths
print 'generated NEW prospector file!'
param_dict = {}
for k, v in sps.csp.params.iteritems(): param_dict[k] = v
#'''
