def write_parameters_outputvalues(self, P):
Mstar, SFR_opt = model.stellar_info_array(self.chain.flatchain_sorted, self.data, self.out['realizations2int'])
column_names = np.transpose(np.array(["P025","P16","P50","P84","P975"], dtype='|S3'))
chain_pars = np.column_stack((self.chain.flatchain_sorted, Mstar, SFR_opt))
# np.mean(chain_pars, axis[0]),
# np.std(chain_pars, axis[0]),
if self.out['calc_intlum']:
SFR_IR = model.sfr_IR(self.int_lums[0]) #check that ['intlum_names'][0] is always L_IR(8-100)
chain_others =np.column_stack((self.int_lums.T, SFR_IR))
outputvalues = np.column_stack((np.transpose(map(lambda v: (v[0],v[1],v[2],v[3],v[4]), zip(*np.percentile(chain_pars, [2.5,16, 50, 84,97.5], axis=0)))),
np.transpose(map(lambda v: (v[0],v[1],v[2],v[3],v[4]), zip(*np.percentile(chain_others, [2.5,16, 50, 84,97.5], axis=0)))),
np.transpose(np.percentile(self.chain.lnprob_flat, [2.5,16, 50, 84,97.5], axis=0)) ))
outputvalues_header= ' '.join([ i for i in np.hstack((P.names, 'log Mstar', 'SFR_opt', self.out['intlum_names'], 'SFR_IR', '-ln_like'))] )
else:
outputvalues = np.column_stack((map(lambda v: (v[1], v[2]-v[1], v[1]-v[0]), zip(*np.percentile(chain_pars, [16, 50, 84], axis=0)))))
outputvalues_header=' '.join( [ i for i in P.names] )
return outputvalues, outputvalues_header
def ymodel(data_nus, z, dictkey_arrays, dict_modelfluxes, *par):
"""Constructs the total model from parameter values.
## inputs: data_nus, z, dictkey_arrays, dict_modelfluxes, *par
## output:
- total model
- bands
- galaxy_flux (to be used by ln_prior)
## dependencies:
This fct is used
(1)in ln_likelihood, this same script.
(2)in scriptPLOTandWRITE.
"""
STARBURSTFdict, BBBFdict, GALAXYFdict, TORUSFdict, _, _, _, _, _ = dict_modelfluxes
gal_do, irlum_dict, nh_dict, BBebv_dict, _ = dictkey_arrays
# Call MCMC-parameter values
tau, agelog, nh, irlum, SB, BB, GA, TO, BBebv, GAebv = par[0:10]
age = 10**agelog
# Pick dictionary key-values, nearest to the MCMC- parameter values
irlum_dct = model.pick_STARBURST_template(irlum, irlum_dict)
nh_dct = model.pick_TORUS_template(nh, nh_dict)
ebvbbb_dct = model.pick_BBB_template(BBebv, BBebv_dict)
gal_do.nearest_par2dict(tau, age, GAebv)
tau_dct, age_dct, ebvg_dct = gal_do.t, gal_do.a, gal_do.e
# Call fluxes from dictionary using keys-values
try:
bands, gal_Fnu = GALAXYFdict[tau_dct, age_dct, ebvg_dct]
bands, sb_Fnu = STARBURSTFdict[irlum_dct]
bands, bbb_Fnu = BBBFdict[ebvbbb_dct]
bands, tor_Fnu = TORUSFdict[nh_dct]
except ValueError:
print 'Error: Dictionary does not contain some values'
# Renormalize to have similar amplitudes. Keep these fixed!
sb_Fnu_norm = sb_Fnu.squeeze() / 1e20
bbb_Fnu_norm = bbb_Fnu.squeeze() / 1e60
gal_Fnu_norm = gal_Fnu.squeeze() / 1e18
tor_Fnu_norm = tor_Fnu.squeeze() / 1e-40
# Total SED sum
#--------------------------------------------------------------------
lum = 10**(SB)* sb_Fnu_norm + 10**(BB)*bbb_Fnu_norm \
+ 10**(GA)*gal_Fnu_norm +(10**TO) *tor_Fnu_norm
#--------------------------------------------------------------------
lum = lum.reshape((np.size(lum), ))
return lum, bands, 10**(GA) * gal_Fnu_norm
def ymodel(data_nus, z, dictkey_arrays, dict_modelfluxes, *par):
"""Constructs the total model from parameter values.
## inputs: data_nus, z, dictkey_arrays, dict_modelfluxes, *par
## output:
- total model
- bands
- galaxy_flux (to be used by ln_prior)
## dependencies:
This fct is used
(1)in ln_likelihood, this same script.
(2)in scriptPLOTandWRITE.
"""
STARBURSTFdict, BBBFdict, GALAXYFdict, TORUSFdict, _, _, _, _, _ = dict_modelfluxes
gal_do, irlum_dict, nh_dict, BBebv_dict, _ = dictkey_arrays
# Call MCMC-parameter values
tau, agelog, nh, irlum, SB, BB, GA, TO, BBebv, GAebv = par[0:10]
age = 10 ** agelog
# Pick dictionary key-values, nearest to the MCMC- parameter values
irlum_dct = model.pick_STARBURST_template(irlum, irlum_dict)
nh_dct = model.pick_TORUS_template(nh, nh_dict)
ebvbbb_dct = model.pick_BBB_template(BBebv, BBebv_dict)
gal_do.nearest_par2dict(tau, age, GAebv)
tau_dct, age_dct, ebvg_dct = gal_do.t, gal_do.a, gal_do.e
# Call fluxes from dictionary using keys-values
try:
bands, gal_Fnu = GALAXYFdict[tau_dct, age_dct, ebvg_dct]
bands, sb_Fnu = STARBURSTFdict[irlum_dct]
bands, bbb_Fnu = BBBFdict[ebvbbb_dct]
bands, tor_Fnu = TORUSFdict[nh_dct]
except ValueError:
print "Error: Dictionary does not contain some values"
# Renormalize to have similar amplitudes. Keep these fixed!
sb_Fnu_norm = sb_Fnu.squeeze() / 1e20
bbb_Fnu_norm = bbb_Fnu.squeeze() / 1e60
gal_Fnu_norm = gal_Fnu.squeeze() / 1e18
tor_Fnu_norm = tor_Fnu.squeeze() / 1e-40
# Total SED sum
# --------------------------------------------------------------------
lum = 10 ** (SB) * sb_Fnu_norm + 10 ** (BB) * bbb_Fnu_norm + 10 ** (GA) * gal_Fnu_norm + (10 ** TO) * tor_Fnu_norm
# --------------------------------------------------------------------
lum = lum.reshape((np.size(lum),))
return lum, bands, 10 ** (GA) * gal_Fnu_norm
def construct_dictionaryarray_filtered(z, filterdict, path, modelsettings):
"""
Construct the dictionaries of fluxes at bands (to compare to data),
and dictionaries of fluxes over the whole spectrum, for plotting.
All calculations are done at one given redshift.
"""
GALAXYFdict_filtered = dict()
STARBURSTFdict_filtered = dict()
BBBFdict_filtered = dict()
TORUSFdict_filtered = dict()
GALAXYFdict_4plot, GALAXY_SFRdict, galaxy_parnames = model.GALAXY(
path, modelsettings)
for c in GALAXYFdict_4plot.keys():
gal_nu, gal_Fnu = GALAXYFdict_4plot[c]
bands, gal_Fnu_filtered = filtering_models(gal_nu, gal_Fnu, filterdict,
z)
GALAXYFdict_filtered[c] = bands, gal_Fnu_filtered
STARBURSTFdict_4plot, starburst_parnames = model.STARBURST(
path, modelsettings)
for c in STARBURSTFdict_4plot.keys():
sb_nu, sb_Fnu = STARBURSTFdict_4plot[c]
bands, sb_Fnu_filtered = filtering_models(sb_nu, sb_Fnu, filterdict, z)
STARBURSTFdict_filtered[c] = bands, sb_Fnu_filtered
BBBFdict_4plot, bbb_parnames = model.BBB(path, modelsettings)
for c in BBBFdict_4plot.keys():
bbb_nu, bbb_Fnu = BBBFdict_4plot[c]
bands, bbb_Fnu_filtered = filtering_models(bbb_nu, bbb_Fnu, filterdict,
z)
BBBFdict_filtered[c] = bands, bbb_Fnu_filtered
TORUSFdict_4plot, torus_parnames = model.TORUS(path, modelsettings)
for c in TORUSFdict_4plot.keys():
tor_nu, tor_Fnu = TORUSFdict_4plot[c]
bands, tor_Fnu_filtered = filtering_models(tor_nu, tor_Fnu, filterdict,
z)
TORUSFdict_filtered[c] = bands, tor_Fnu_filtered
norm_parnames = ['GA', 'SB', 'BB', 'TO']
all_parnames = [
galaxy_parnames, starburst_parnames, torus_parnames, bbb_parnames,
norm_parnames
]
return STARBURSTFdict_filtered , BBBFdict_filtered, GALAXYFdict_filtered, TORUSFdict_filtered, \
STARBURSTFdict_4plot , BBBFdict_4plot, GALAXYFdict_4plot, TORUSFdict_4plot,GALAXY_SFRdict, all_parnames
def chi_squared_value(self):
#######Calculate chi-squared value of best-fit SED, excludes upper limits
###returns: chi-squared and number of filters used in fit
ydata = self.data.fluxes[self.data.fluxes > 0.]
yerror = self.data.fluxerrs[self.data.fluxes > 0.]
yndflags = self.data.ndflag[self.data.fluxes > 0.]
data_nus_obs = 10**self.data.nus[self.data.fluxes > 0.]
distance = model.z2Dlum(self.z)
lumfactor = (4. * math.pi * distance**2.)
data_nuLnu_rest = ydata * data_nus_obs * lumfactor
data_errors_rest = yerror * data_nus_obs * lumfactor
det = [yndflags == 1]
upp = [yndflags == 0]
model_y = self.filtered_modelpoints_nuLnu_best[
self.data.fluxes > 0.][det]
obs_y = data_nuLnu_rest[det]
obs_err = data_errors_rest[det]
nfilters = len(obs_y)
diff = [(obs_y[x] - model_y[x])**2 / (obs_err[x]**2)
for x in xrange(nfilters)]
chi_squared = np.sum(diff)
return chi_squared, nfilters
def galaxy_Lumfct_prior(dict_modelsfiles, dict_modelfluxes, z, *par): # Calculated B-band at this parameter space point h_70 = 1. distance = model.z2Dlum(z)#/3.08567758e24 lumfactor = (4. * pi * distance**2.) bands, gal_flux = galaxy_flux(dict_modelsfiles, dict_modelfluxes, *par) # array = np.arange(len(bands)) # x_B = np.int(array[(14.87 > bands > 14.80)]) flux_B = gal_flux[(14.87 > bands > 14.80)] # mag1= -2.5 * np.log10(flux_B) - 48.6 # distmod = -5.0 * np.log10((distance/3.08567758e24 *1e6)/10) # abs_mag1 = mag1 + distmod # thispoint1 = abs_mag1 lum_B = lumfactor * flux_B thismag = 51.6 - 2.5 *np.log10(lum_B) # Expected B-band calculation expected = -20.3 - (5 * np.log10(h_70) )- (1.1 * z) return expected,thismag
def plot_manyrealizations_SED(self):
#reading from valid data from object data
ydata = self.data.fluxes[self.data.fluxes>0.]
yerror = self.data.fluxerrs[self.data.fluxes>0.]
yndflags = self.data.ndflag[self.data.fluxes>0.]
Nrealizations = self.out['realizations2plot']
#Data frequencies (obs and rest), and model frequencies
data_nus_obs = 10**self.data.nus[self.data.fluxes>0.]
data_nus_rest = data_nus_obs * (1+self.z)
data_nus = np.log10(data_nus_rest)
all_nus =self.allnus
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus / (1+self.z) #observed
distance= model.z2Dlum(self.z)
lumfactor = (4. * math.pi * distance**2.)
data_nuLnu_rest = ydata* data_nus_obs *lumfactor
data_errors_rest= yerror * data_nus_obs * lumfactor
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = self.nuLnus
#plotting settings
fig, ax1, ax2 = SED_plotting_settings(all_nus_rest, data_nuLnu_rest, self.allnus)
SBcolor, BBcolor, GAcolor, TOcolor, TOTALcolor= SED_colors(combination = 'a')
lw= 1.5
li = []
for i in range(Nrealizations):
#Settings for model lines
p2=ax1.plot(all_nus, SBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= SBcolor, alpha = 0.5)
p3=ax1.plot(all_nus, BBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= BBcolor, alpha = 0.5)
p4=ax1.plot(all_nus, GAnuLnu[i],marker="None", linewidth=lw, label="1 /sigma",color=GAcolor, alpha = 0.5)
p5=ax1.plot( all_nus, TOnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= TOcolor ,alpha = 0.5)
p1= ax1.plot( all_nus, TOTALnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= TOTALcolor, alpha= 0.5)
p6 = ax1.plot(data_nus, self.filtered_modelpoints_nuLnu[i][self.data.fluxes>0.], marker='o', linestyle="None",markersize=5, color="red", alpha =0.7)
det = [yndflags==1]
upp = [yndflags==0]
upplimits = ax1.errorbar(data_nus[upp], 2.*data_nuLnu_rest[upp], yerr= data_errors_rest[upp]/2, uplims = True, linestyle='', markersize=5, color="black")
(_, caps, _) = ax1.errorbar(data_nus[det], data_nuLnu_rest[det], yerr= data_errors_rest[det], capsize=4, linestyle="None", linewidth=1.5, marker='o',markersize=5, color="black", alpha = 1)
ra = self.filtered_modelpoints_nuLnu[i][self.data.fluxes>0.]
li.append(np.sum(abs(data_nuLnu_rest[data_nus<13.]-ra[data_nus<13.])))
#print np.sum(li)
ax1.annotate(r'XID='+str(self.data.name)+r', z ='+ str(self.z), xy=(0, 1), xycoords='axes points', xytext=(20, 250), textcoords='axes points' )#+ ', log $\mathbf{L}_{\mathbf{IR}}$= ' + str(Lir_agn) +', log $\mathbf{L}_{\mathbf{FIR}}$= ' + str(Lfir) + ', log $\mathbf{L}_{\mathbf{UV}} $= '+ str(Lbol_agn)
print ' => SEDs of '+ str(Nrealizations)+' different realization were plotted.'
return fig, np.sum(li)/Nrealizations
def write_parameters_outputvalues(self, P):
Mstar, SFR_opt = model.stellar_info_array(self.chain.flatchain_sorted,
self.data,
self.out['realizations2int'])
column_names = np.transpose(
np.array(["P025", "P16", "P50", "P84", "P975"], dtype='|S3'))
chain_pars = np.column_stack(
(self.chain.flatchain_sorted, Mstar, SFR_opt))
# np.mean(chain_pars, axis[0]),
# np.std(chain_pars, axis[0]),
if self.out['calc_intlum']:
SFR_IR = model.sfr_IR(
self.int_lums[0]
) #check that ['intlum_names'][0] is always L_IR(8-100)
chain_others = np.column_stack((self.int_lums.T, SFR_IR))
outputvalues = np.column_stack(
(np.transpose(
map(
lambda v: (v[0], v[1], v[2], v[3], v[4]),
zip(*np.percentile(chain_pars, [2.5, 16, 50, 84, 97.5],
axis=0)))),
np.transpose(
map(
lambda v: (v[0], v[1], v[2], v[3], v[4]),
zip(*np.percentile(
chain_others, [2.5, 16, 50, 84, 97.5], axis=0)))),
np.transpose(
np.percentile(self.chain.lnprob_flat,
[2.5, 16, 50, 84, 97.5],
axis=0))))
outputvalues_header = ' '.join([
i for i in np.hstack((P.names, 'log Mstar', 'SFR_opt',
self.out['intlum_names'], 'SFR_IR',
'-ln_like'))
])
else:
outputvalues = np.column_stack(
(map(lambda v: (v[1], v[2] - v[1], v[1] - v[0]),
zip(*np.percentile(chain_pars, [16, 50, 84], axis=0)))))
outputvalues_header = ' '.join([i for i in P.names])
return outputvalues, outputvalues_header
def PLOT_SED_manyrealizations(source, data_nus_0, ydata_0, yerror_0, z, all_nus, FLUXES4plotting, Nrealizations, filtered_modelpoints, index_dataexist):
# Choosing only existing data points (source-dependent: not total CATALOG array)
data_nus = data_nus_0[index_dataexist]
ydata = ydata_0[index_dataexist]
yerror = yerror_0[index_dataexist]
#data nuLnu
data_nus_obs = 10**data_nus
data_nus_rest = 10**data_nus * (1+z)
data_nus = np.log10(data_nus_rest)
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus / (1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
data_nuLnu_rest = ydata* data_nus_obs *lumfactor
data_errors_rest= yerror * data_nus_obs * lumfactor
fig, ax1, ax2 = SED_plotting_settings(all_nus_rest, data_nuLnu_rest)
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z)
SBcolor, BBcolor, GAcolor, TOcolor, TOTALcolor= SED_colors(combination = 'a')
lw= 1.5
thinning_4plot = len(TOTALnuLnu) / (Nrealizations)
for j in range(Nrealizations):
i = j * 10
#Settings for model lines
p2=ax1.plot(all_nus, SBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= SBcolor, alpha = 0.5)
p3=ax1.plot(all_nus, BBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= BBcolor, alpha = 0.5)
p4=ax1.plot( all_nus, GAnuLnu[i],marker="None", linewidth=lw, label="1 /sigma",color=GAcolor, alpha = 0.5)
p5=ax1.plot( all_nus, TOnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= TOcolor ,alpha = 0.5)
p1= ax1.plot( all_nus, TOTALnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= TOTALcolor, alpha= 0.5)
interp_total= interp1d(all_nus, TOTALnuLnu[i], bounds_error=False, fill_value=0.)
TOTALnuLnu_at_datapoints = interp_total(data_nus)
(_, caps, _) = ax1.errorbar(data_nus, data_nuLnu_rest, yerr= data_errors_rest, capsize=4, linestyle="None", linewidth=1.5, marker='o',markersize=5, color="black", alpha = 0.5)
p6 = ax1.plot(data_nus, TOTALnuLnu_at_datapoints , marker='o', linestyle="None",markersize=5, color="red")
# p6 = ax1.plot(np.log10(10**data_nus_0 *(1+z)), filtered_modelpoints[i] , marker='o', linestyle="None",markersize=5, color="red")
ax1.annotate(r'XID='+str(source)+r', z ='+ str(z), xy=(0, 1), xycoords='axes points', xytext=(20, 310), textcoords='axes points' )#+ ', log $\mathbf{L}_{\mathbf{IR}}$= ' + str(Lir_agn) +', log $\mathbf{L}_{\mathbf{FIR}}$= ' + str(Lfir) + ', log $\mathbf{L}_{\mathbf{UV}} $= '+ str(Lbol_agn)
print ' => SEDs of '+ str(Nrealizations)+' different realization were plotted.'
return fig
def PLOT_SED_bestfit(source, data_nus_0, ydata_0, yerrors_0, z, all_nus, FLUXES4plotting, filtered_modelpoints, index_dataexist):
# Choosing only existing data points (source-dependent: not total CATALOG array)
data_nus = data_nus_0[index_dataexist]
data_flux = ydata_0[index_dataexist]
data_errors = yerrors_0[index_dataexist]
data_nus_obs = 10**data_nus
data_nus_rest =10**data_nus*(1+z) #rest
data_nus =np.log10(data_nus_rest)
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus/(1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
data_nuLnu_rest = data_flux* data_nus_obs *lumfactor
data_errors_rest= data_errors * data_nus_obs * lumfactor
fig, ax1, ax2 = SED_plotting_settings(all_nus_rest, data_nuLnu_rest)
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = [f[0] for f in FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z)]
SBFnu_array, BBFnu_array, GAFnu_array, TOFnu_array, TOTALFnu_array,BBFnu_array_deredd = FLUXES4plotting
np.savetxt('/data2/calistro/Dropbox/totalnuLnu_'+str(source)+'.txt', np.column_stack((all_nus_rest, TOTALnuLnu)))#TOTALFnu_array.T)))
# print np.shape(filtered_modelpoints), np.shape(data_nus_0), np.shape(data_nus)
# filtered_modelpoints_best = filtered_modelpoints * (10**data_nus_0) * lumfactor
#Settings for model lines
SBcolor, BBcolor, GAcolor, TOcolor, TOTALcolor= SED_colors(combination = 'a')
lw= 1.5
p1= ax1.plot( all_nus, TOTALnuLnu, marker="None", linewidth=lw, label="1 /sigma", color= TOTALcolor, alpha= 1.0)
p2=ax1.plot(all_nus, SBnuLnu, marker="None", linewidth=lw, label="1 /sigma", color= SBcolor, alpha = 0.6)
p3=ax1.plot(all_nus, BBnuLnu, marker="None", linewidth=lw, label="1 /sigma",color= BBcolor, alpha = 0.6)
p4=ax1.plot( all_nus, GAnuLnu,marker="None", linewidth=lw, label="1 /sigma",color=GAcolor, alpha = 0.6)
p5=ax1.plot( all_nus, TOnuLnu, marker="None", linewidth=lw, label="1 /sigma",color= TOcolor, alpha = 0.6)
interp_total= interp1d(all_nus, TOTALnuLnu, bounds_error=False, fill_value=0.)
TOTALnuLnu_at_datapoints = interp_total(data_nus)
# p6 = ax1.plot(np.log10(10**data_nus_0*(1+z)), filtered_modelpoints_best[0] , marker='o', linestyle="None", markersize=5, color="red")
#p6 = ax1.plot(data_nus, TOTALnuLnu_at_datapoints , marker='o', linestyle="None", markersize=5, color="red")
(_, caps, _) = ax1.errorbar(data_nus, data_nuLnu_rest, yerr= data_errors_rest, capsize=4, linestyle="None", linewidth=1.5, marker='o',markersize=5, color="black", alpha = 0.5)
ax1.annotate(r'XID='+str(source)+r', z ='+ str(z), xy=(0, 1), xycoords='axes points', xytext=(20, 310), textcoords='axes points' )#+ ', log $\mathbf{L}_{\mathbf{IR}}$= ' + str(Lir_agn) +', log $\mathbf{L}_{\mathbf{FIR}}$= ' + str(Lfir) + ', log $\mathbf{L}_{\mathbf{UV}} $= '+ str(Lbol_agn)
#plt.savefig(folder+str(source)+'/SEDbest_'+str(source)+'.pdf', format = 'pdf')#, dpi = 900
print ' => Best fit SED was plotted.'
return fig
def FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z):
all_nus_rest = all_nus_rest
all_nus_obs = all_nus_rest /(1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, iSBnuLnu, iBBnuLnu, iGAnuLnu, iTOnuLnu, iTOTALnuLnu,iBBnuLnu_deredd = [ f *lumfactor*all_nus_obs for f in FLUXES4plotting]
return SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, iSBnuLnu, iBBnuLnu, iGAnuLnu, iTOnuLnu, iTOTALnuLnu,iBBnuLnu_deredd
def plot_manyrealizations_SED(self):
#reading from valid data from object data
ydata = self.data.fluxes[self.data.fluxes>0.]
yerror = self.data.fluxerrs[self.data.fluxes>0.]
yndflags = self.data.ndflag[self.data.fluxes>0.]
Nrealizations = self.out['realizations2plot']
#Data frequencies (obs and rest), and model frequencies
data_nus_obs = 10**self.data.nus[self.data.fluxes>0.]
data_nus_rest = data_nus_obs * (1+self.z)
data_nus = np.log10(data_nus_rest)
all_nus =self.allnus
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus / (1+self.z) #observed
distance= model.z2Dlum(self.z)
lumfactor = (4. * math.pi * distance**2.)
data_nuLnu_rest = ydata* data_nus_obs *lumfactor
data_errors_rest= yerror * data_nus_obs * lumfactor
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = self.nuLnus
#plotting settings
fig, ax1, ax2 = SED_plotting_settings(all_nus_rest, data_nuLnu_rest)
SBcolor, BBcolor, GAcolor, TOcolor, TOTALcolor= SED_colors(combination = 'a')
lw= 1.5
for i in range(Nrealizations):
#Settings for model lines
p2=ax1.plot(all_nus, SBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= SBcolor, alpha = 0.5)
p3=ax1.plot(all_nus, BBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= BBcolor, alpha = 0.5)
p4=ax1.plot(all_nus, GAnuLnu[i],marker="None", linewidth=lw, label="1 /sigma",color=GAcolor, alpha = 0.5)
p5=ax1.plot( all_nus, TOnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= TOcolor ,alpha = 0.5)
p1= ax1.plot( all_nus, TOTALnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= TOTALcolor, alpha= 0.5)
p6 = ax1.plot(data_nus, self.filtered_modelpoints_nuLnu[i][self.data.fluxes>0.], marker='o', linestyle="None",markersize=5, color="red", alpha =0.7)
det = [yndflags==1]
upp = [yndflags==0]
upplimits = ax1.errorbar(data_nus[upp], 2.*data_nuLnu_rest[upp], yerr= data_errors_rest[upp]/2, uplims = True, linestyle='', markersize=5, color="black")
(_, caps, _) = ax1.errorbar(data_nus[det], data_nuLnu_rest[det], yerr= data_errors_rest[det], capsize=4, linestyle="None", linewidth=1.5, marker='o',markersize=5, color="black", alpha = 1)
ax1.annotate(r'XID='+str(self.data.name)+r', z ='+ str(self.z), xy=(0, 1), xycoords='axes points', xytext=(20, 310), textcoords='axes points' )#+ ', log $\mathbf{L}_{\mathbf{IR}}$= ' + str(Lir_agn) +', log $\mathbf{L}_{\mathbf{FIR}}$= ' + str(Lfir) + ', log $\mathbf{L}_{\mathbf{UV}} $= '+ str(Lbol_agn)
print ' => SEDs of '+ str(Nrealizations)+' different realization were plotted.'
return fig
def FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z):
"""
input: all_nus_rest (10** , NOT log!!!!)
"""
all_nus_rest = all_nus_rest
all_nus_obs = all_nus_rest /(1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = [ f *lumfactor*all_nus_obs for f in FLUXES4plotting]
return SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd
def galaxy_flux(dict_modelsfiles, dict_modelfluxes, *par):
all_tau, all_age, _, _, filename_0_galaxy, _, _ = dict_modelsfiles
_, _, GALAXYFdict, _, _, EBVgal_array= dict_modelfluxes
# calling parameters from Emcee
tau, agelog, _, _, _ ,_, GA,_, _, GAebv= par[0:10]
age = 10**agelog
GA_filename = model.pick_GALAXY_template(tau, age, filename_0_galaxy, all_tau, all_age)
EBV_gal_0 = model.pick_EBV_grid(EBVgal_array,GAebv)
EBV_gal = ( str(int(EBV_gal_0)) if float(EBV_gal_0).is_integer() else str(EBV_gal_0))
try:
bands, gal_Fnu = GALAXYFdict[GA_filename, EBV_gal]
except ValueError:
print 'Error: Dictionary does not contain key of ', GA_filename, EBV_gal, ' or the E(B-V) grid or the DICTIONARIES_AGNfitter file does not match when the one used in PARAMETERSPACE_AGNfitter/ymodel.py'
gal_Fnu *= 1e-18 * 10**(GA)
return bands, gal_Fnu
def Pdict(data):
"""Constructs a dictionary P with the name of all model parameters as keys.
The values are tuples with the same length, with the parameter limits.
## inputs:
- data object
"""
P = adict()
P.names = "tau", "age", "Nh", "irlum", "SB", "BB", "GA", "TO", "EBVbbb", "EBVgal"
P.min = 0.0, 5.0, 21.0, 7.0, 0.0, 0.0, 0.0, 0.0, -0.1, -0.1
P.max = 15, np.log10(model.maximal_age(data.z)), 25, 15, 10.0, 10.0, 10.0, 10.0, 1.0, 1.0
Npar = len(P.names)
return P
def Pdict(data):
"""Constructs a dictionary P with the name of all model parameters as keys.
The values are tuples with the same length, with the parameter limits.
## inputs:
- data object
"""
P = adict()
P.names = 'tau', 'age', 'Nh', 'irlum', 'SB', 'BB', 'GA', 'TO', 'EBVbbb', 'EBVgal'
P.min = 0., 5., 21., 7., 0., 0., 0., 0., -0.1, -0.1
P.max = 15, np.log10(model.maximal_age(
data.z)), 25, 15, 10., 10., 10., 10., 1.0, 1.0
Npar = len(P.names)
return P
def FLUXES2nuLnu_4plotting(self, all_nus_rest, FLUXES4plotting, z):
"""
Converts FLUXES4plotting into nuLnu_4plotting.
##input:
- all_nus_rest (give in 10^lognu, not log.)
- FLUXES4plotting : fluxes for the four models corresponding
to each element of the total chain
- source redshift z
"""
all_nus_obs = 10**all_nus_rest /(1+z)
distance= model.z2Dlum(z)
lumfactor = (4. * math.pi * distance**2.)
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = [ f *lumfactor*all_nus_obs for f in FLUXES4plotting]
return SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd
def FLUXES2nuLnu_4plotting(self, all_nus_rest, FLUXES4plotting, z):
"""
Converts FLUXES4plotting into nuLnu_4plotting.
##input:
- all_nus_rest (give in 10^lognu, not log.)
- FLUXES4plotting : fluxes for the four models corresponding
to each element of the total chain
- source redshift z
"""
all_nus_obs = 10**all_nus_rest /(1+z)
distance= model.z2Dlum(z)
lumfactor = (4. * math.pi * distance**2.)
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd = [ f *lumfactor*all_nus_obs for f in FLUXES4plotting]
return SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd
def MOCKdata (z, dict_modelfiles, dict_modelfluxes, parameters): all_tau, all_age, all_nh, all_irlum, filename_0_galaxy, filename_0_starburst, filename_0_torus = dict_modelsfiles STARBURSTFdict , BBBFdict, GALAXYFdict, TORUSFdict, EBVbbb_array, EBVgal_array = dict_modelfluxes tau, age, nh, irlum, SB ,BB, GA,TO, BBebv, GAebv = parameters SB_filename = model.pick_STARBURST_template(irlum, filename_0_starburst, all_irlum) GA_filename = model.pick_GALAXY_template(tau, age, filename_0_galaxy, all_tau, all_age) TOR_filename = model.pick_TORUS_template(nh, all_nh, filename_0_torus) BB_filename = model.pick_BBB_template() EBV_bbb_0 = model.pick_EBV_grid(EBVbbb_array, BBebv) EBV_bbb = ( str(int(EBV_bbb_0)) if float(EBV_bbb_0).is_integer() else str(EBV_bbb_0)) EBV_gal_0 = model.pick_EBV_grid(EBVgal_array,GAebv) EBV_gal = ( str(int(EBV_gal_0)) if float(EBV_gal_0).is_integer() else str(EBV_gal_0)) if (GA_filename, EBV_gal) in GALAXYFdict: bands, gal_Fnu = GALAXYFdict[GA_filename, EBV_gal] else: print 'Error: Dictionary does not contain key of ', GA_filename, EBV_gal, ' or the E(B-V) grid or the DICTIONARIES_AGNfitter file does not match when the one used in PARAMETERSPACE_AGNfitter/ymodel.py' if SB_filename in STARBURSTFdict: bands, sb_Fnu= STARBURSTFdict[SB_filename] else: print 'Error: Dictionary does not contain key'+SB_filename+'. all STARBURST files or the E(B-V) grid.' if (BB_filename, EBV_bbb) in BBBFdict: bands, bbb_Fnu = BBBFdict[BB_filename, EBV_bbb] else: print'Error: Dictionary does not contain key: '+ BB_filename, EBV_bbb +'or the E(B-V) grid of the DICTIONARIES_AGNfitter file does not match when the one used in PARAMETERSPACE_AGNfitter/ymodel.py' if TOR_filename in TORUSFdict: bands, tor_Fnu= TORUSFdict[TOR_filename] else: print 'Error: Dictionary does not contain TORUS file:'+TOR_filename NormalizationFLux = 1e-28 # This is the flux to which the models are normalized to have comparable NORM factors sb_Fnu_norm = sb_Fnu / 1e18 bbb_Fnu_norm = bbb_Fnu / 1e58 gal_Fnu_norm = gal_Fnu/ 1e12 tor_Fnu_norm = tor_Fnu/ 1e-42 # Sum components # ---------------------------------------------------------------------------------------------------------------------------------------------------------# lum = 10**(SB)* sb_Fnu_norm + 10**(BB)*bbb_Fnu_norm + (10**GA)*gal_Fnu_norm + 10**TO *tor_Fnu_norm #----------------------------------------------------------------------------------------------------------------------------------------------------------- mockfluxes_array = lum.reshape((np.size(lum),)) return bands, mockfluxes_array
def Pdict (catalog, sourceline):
"""
This function constructs a dictionary P with keys. The value of every key is a tuple with the
same length (the number of model parameters)
name : parameter names
min : minimum allowed parameter values
max : maximum allowed parameter values
## inputs:
- catalog file name
- sourcelines
## output:
- dictionary P with all parameter characteristics
## comments:
-
## bugs:
"""
P = adict()
#Constrains on the age of the galaxy:
z = REDSHIFT(catalog, sourceline)
# ----------------------------|--------------|--------------|---------------|-----------|-----------|------------|-----------|------------|-------------|------------|
P.names = 'tau' , 'age', 'nh', 'irlum' , 'SB', 'BB', 'GA', 'TO', 'BBebv', 'GAebv'
# -------------------------|-------------|-------------|---------------|-----------|-----------|------------|-----------|------------|-------------|------------| For F_nu
P.min = 0 , 6, 21, 7, 0, 0, 0, 0, 0, 0
P.max = 3.5, np.log10(model.maximal_age(z)), 25, 15, 10, 10, 10, 10, 1, 0.5
# -------------------------|-------------|-------------|-----------|-----------|------------|-----------|------------|-------------|------------|
Npar = len(P.names)
#
return P
def PLOT_SED_bestfit(source, data_nus, data_flux, data_errors, z, all_nus, FLUXES4plotting, filtered_modelpoints, ifiltered_modelpoints1):
data_nus_obs = 10**data_nus
data_nus_rest =10**data_nus*(1+z) #rest
data_nus =np.log10(data_nus_rest)
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus/(1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
data_nuLnu_rest = data_flux* data_nus_obs *lumfactor
data_errors_rest= data_errors * data_nus_obs * lumfactor
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, _, _, _, _,_, _ = [f[0] for f in FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z)]
_, _, _, _, _, _,iSBnuLnu, iBBnuLnu, iGAnuLnu, iTOnuLnu, iTOTALnuLnu,iBBnuLnu_deredd =FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z)
filtered_modelpoints_best = filtered_modelpoints * data_nus_obs * lumfactor
ifiltered_modelpoints = ifiltered_modelpoints1* data_nus_obs * lumfactor
return SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, filtered_modelpoints_best, iSBnuLnu, iBBnuLnu, iGAnuLnu, iTOnuLnu, iTOTALnuLnu,iBBnuLnu_deredd, ifiltered_modelpoints
def PLOT_SED_manyrealizations(source, data_nus, ydata, yerror, z, all_nus, FLUXES4plotting, filtered_modelpoints1, Nrealizations):
#data nuLnu
data_nus_obs = 10**data_nus
data_nus_rest = 10**data_nus * (1+z)
data_nus = np.log10(data_nus_rest)
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus / (1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
data_nuLnu_rest = ydata* data_nus_obs *lumfactor
data_errors_rest=yerror * data_nus_obs * lumfactor
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, _, _, _, _,_, _ = FLUXES2nuLnu_4plotting(all_nus_rest, FLUXES4plotting, z)
#data_errors_rest= data_errors * data_nus_obs * lumfactor
filtered_modelpoints = filtered_modelpoints1* data_nus_obs * lumfactor
return SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, filtered_modelpoints
def main(filename, catalog, sourceline, P, folder, opt, dict_modelsfiles, filterdict, path_AGNfitter, dict_modelfluxes):
z = REDSHIFT(catalog, sourceline)
sourcename = NAME(catalog, sourceline)
data_nus, ydata, ysigma = DATA(catalog, sourceline)
array = np.arange(len(data_nus))
index_dataexist = array[(data_nus< np.log10(10**(15.38)/(1+z))) & (ydata>-99.)]
path = os.path.abspath(__file__).rsplit('/', 1)[0]
if not os.path.lexists(folder+str(sourcename)+'/samples_mcmc.sav'):
print 'Error: The MCMC sampling has not been perfomed yet, or the chains were not saved properly.'
#==============================================
samples = general.loadobj(filename)
nwalkers, nsamples, npar = samples['chain'].shape
nwalkers, nsamples, npar = samples['chain'].shape
mean_accept = samples['accept'].mean()
print 'Mean acceptance fraction', mean_accept
if opt['plottraces_burn-in'] :
#=================== BURN-IN =================
if filename.startswith(folder+str(sourcename)+'/samples_burn1-2-3'):
if opt['plottraces_burn-in'] :
print 'Plotting traces of burn-in'
fig, nwplot = plot_trace_burnin123(P, samples['chain'], samples['lnprob'])
fig.suptitle('Chain traces for %i steps of %i walkers' % (nwplot,nwalkers))
fig.savefig(folder+str(sourcename)+'/traces1-2-3.' + opt['plotformat'])
pl.close(fig)
if opt['plotautocorr'] :
fig, axes = general.plot_autocorr(samples['chain'], P)
fig.suptitle('Autocorrelation for %i walkers with %i samples. '
'(Mean acceptance fraction %.2f)' %
(nwalkers, nsamples, mean_accept), fontsize=14)
fig.savefig(folder+str(sourcename)+'/autocorr1-2-3.' + opt['plotformat'])
#===================MCMC=====================
if filename.startswith(folder+str(sourcename)+'/samples_mcmc'):
#Thinning
Ns, Nt = opt['Nsample'], opt['Nthinning']
assert Ns * Nt <= nsamples
chain_flat = samples['chain'][:,0:Ns*Nt:Nt,:].reshape(-1, npar)
#mix all walkers' steps into one chain
#of shape [(nwalkers*steps), parameters]
lnprob = samples['lnprob'][:,0:Ns*Nt:Nt].ravel()
isort = (-lnprob).argsort() #sort parameter vector for likelihood
lnprob_sorted = np.reshape(lnprob[isort],(-1,1))
lnprob_max = lnprob_sorted[0]
chain_flat_sorted = chain_flat[isort]
best_fit_par = chain_flat[isort[0]]
total_length_chain = int(len(chain_flat))
Nthin_compute = opt['realizations2compute'] #thinning chain to compute small
#number of luminosities
Nrealizations = opt['realizations2plot'] #thinning it even more
#for doing fewer superposed plots
all_nus, FLUXES4plotting, filtered_modelpoints = fluxes_arrays(data_nus, catalog, sourceline, dict_modelsfiles, filterdict, chain_flat_sorted, Nthin_compute,path_AGNfitter, dict_modelfluxes)
# calculate the model fluxes, mapping parameter space values to observables.
#=================PLOT_TRACES===================
if opt['plottraces_mcmc'] :
print 'Plotting traces of mcmc'
fig, nwplot = plot_trace_mcmc(P, samples['chain'],samples['lnprob'])
fig.suptitle('Chain traces for %i of %i walkers. Main acceptance fraction: %f' % (nwplot,nwalkers,mean_accept))
fig.savefig(folder+str(sourcename)+'/traces_mcmc.' + opt['plotformat'])
pl.close(fig)
#===============INTEGRATE LUMINOSITIES=================
if opt['integratedlum']:
print 'Computing integrated luminosities Loptuv_GA, LMir_TO, LMir_SB, Loptuv_BB, LFir_8-1000'
#print 'Saving in: ', folder + str(sourcename)+'/integrated_luminosities_'+str(sourcename)+'.txt'
L0, L1, L2, L3, L4 , L5=integrated_luminosities_arrays(all_nus, FLUXES4plotting, Nthin_compute, total_length_chain, z, folder, sourcename)
#Loptuv_BB, Loptuv_GA, LMir_TO, LMir_SB, Loptuv_BB, LFir_8-1000
#==================PLOT PDF TRIANGLE=================
if opt['posteriortriangle']:
print 'Plotting triangle of PDFs of parameters.'
figure = plot_posteriors_triangle_pars(chain_flat, best_fit_par)
figure.savefig(folder+str(sourcename)+'/posterior_triangle_pars_'+str(sourcename)+'.' + opt['plotformat'])
pl.close(figure)
### change this opt to opt['posteriortriangleofluminosities]
if opt['posteriortrianglewithluminosities'] :
if not os.path.lexists(folder+str(sourcename)+'/integrated_luminosities_'+str(sourcename)+'.txt'):
L0, L1, L2, L3, L4, L5 =integrated_luminosities_arrays(all_nus, FLUXES4plotting, Nthin_compute, total_length_chain ,z, folder, sourcename)
print 'Plotting triangle of PDFs of derived quantities.'
L0, L1, L2, L3, L4, L5 = np.loadtxt(folder + str(sourcename)+'/integrated_luminosities_'+str(sourcename)+'.txt', usecols=(0,1,2,3,4,5),unpack= True)
chain_others = np.column_stack((L0, L1, L2, L3, L4, L5))
chain_luminosities = np.column_stack((L0, L1, L2, L3, L4, L5))
figure2= plot_posteriors_triangle_other_quantities(chain_others)
figure2.savefig(folder+str(sourcename)+'/posterior_triangle_others_'+str(sourcename)+'.'+ opt['plotformat'])
pl.close(figure2)
#-==========PRINT PARAMETERS WITH UNCERTAINTIES=============
if opt['printpar_meanwitherrors']:
if not opt['integratedlum']:
L0, L1, L2, L3, L4, L5 =integrated_luminosities_arrays(all_nus, FLUXES4plotting, Nthin_compute, total_length_chain ,z, folder, sourcename)
print 'Printing mean values of the parameters with corresponding errors.'
chain_pars_and_others = np.column_stack((chain_flat_sorted, L0, L1, L2, L3, L4, L5 ))
tau_e, age_e, nh_e, irlum_e, SB_e, BB_e, GA_e, TO_e, BBebv_e, GAebv_e, L0_e, L1_e, L2_e, L3_e, L4_e, L5_e = parameters_with_errors(chain_pars_and_others)
parameters_with_errors_transpose= np.transpose(parameters_with_errors(chain_pars_and_others))
L5_e_transpose = np.transpose(L5_e)
Mstar_e, SFR_e, SFR_file_e = model.stellar_info(parameters_with_errors_transpose, catalog, sourceline, path_AGNfitter)
SFR_IR_e = model.sfr_IR(L5_e)
Mstar_e = np.reshape(Mstar_e,(-1,1))
SFR_e = np.reshape(SFR_e,(-1,1))
SFR_file_e = np.reshape(SFR_file_e,(-1,1))
SFR_IR_e = np.reshape(SFR_IR_e, (-1,1))
#L0_e, L1_e, L2_e, L3_e, L4_e is L_sb, L_bbb, L_ga, L_to, Lbb_dered
output_error = np.column_stack((tau_e, age_e, nh_e, irlum_e, SB_e, BB_e, GA_e, TO_e, BBebv_e, GAebv_e, Mstar_e, SFR_e, SFR_file_e, L0_e, L1_e, L2_e, L3_e, L4_e, L5_e, SFR_IR_e))
np.savetxt(folder + str(sourcename)+'/parameters_with_errors_1_'+str(sourcename)+'.txt' , output_error, delimiter = " ",fmt="%s" ,header="tau_e, age_e, nh_e, irlum_e, SB_e, BB_e, GA_e, TO_e, BBebv_e, GAebv_e, Mstar_e, SFR_e, SFR_file_e, L0_e, L1_e, L2_e, L3_e, L4_e, L5_e, SFR_IR ")
if opt['printpar_onesigmarealisations']:
#ERASE
print 'Printint all values of the parameters corresponding to realisation with the best 65% likelihoods.'
#-==========PRINT MAX LIKELIHOOD=============
if opt['printpar_maxlikelihood']:
print 'Printing parameters of maximum likelihood'
distance = model.z2Dlum(z)
Mstar, SFR, SFR_file = model.stellar_info_best(best_fit_par, catalog, sourceline, path_AGNfitter)
L0_b = L0[0]
L1_b = L1[0]
L2_b= L2[0]
L3_b= L3[0]
L4_b = L4[0]
L5_b = L5[0]
L5_reshaped=np.reshape(L5[0],(-1,1))
SFR_IR =np.reshape((model.sfr_IR(L5_reshaped)), (1))
output = np.hstack((best_fit_par, np.log10(Mstar), SFR, SFR_file , lnprob_max, L0_b, L1_b, L2_b, L3_b, L4_b, L5_b ,SFR_IR))
output_names = np.array(['tau ','age',' nhv',' irlum ','SB',' BB ','GA',' TO ','BBebv ','GAebv ','Mstar ','SFR ','SFR_file','ln_likelihood','L0_b', 'L1_b', 'L2_b', 'L3_b', 'L4_b', 'L5_b','SFR_IR'])
np.savetxt(folder + str(sourcename)+'/max_likelihood_parameters_1_'+ str(sourcename) + '.txt' , np.column_stack((output, output_names)), delimiter = " ",fmt="%s" ,header="Maximum likelihood parameters (Chi2Minimization)")
#===================PLOT SEDS=======================
if opt['plotSEDbest']:
fig = PLOT_SED_bestfit(sourcename, data_nus, ydata, ysigma, z, all_nus, FLUXES4plotting, filtered_modelpoints, index_dataexist)
plt.savefig(folder+str(sourcename)+'/SED_best_'+str(sourcename)+'.pdf', format = 'pdf')
plt.close(fig)
if opt['plotSEDrealizations']:
fig = PLOT_SED_manyrealizations(sourcename, data_nus, ydata, ysigma, z, all_nus, FLUXES4plotting, Nrealizations, filtered_modelpoints, index_dataexist)
plt.savefig(folder+str(sourcename)+'/SED_realizations_'+str(sourcename)+'.pdf', format = 'pdf')
plt.close(fig)
print '************ =) ***********'
def fluxes(self, data):
"""
This is the main function of the class.
"""
self.chain_obj.props()
SBFnu_list = []
BBFnu_list = []
GAFnu_list = []
TOFnu_list = []
TOTALFnu_list = []
BBFnu_deredd_list = []
if self.output_type == 'plot':
filtered_modelpoints_list = []
gal_do, irlum_dict, nh_dict, BBebv_dict, _ = data.dictkey_arrays
# Take the last 4 dictionaries, which are for plotting. (the first 4 were at bands)
_, _, _, _, STARBURSTFdict, BBBFdict, GALAXYFdict, TORUSFdict, _ = data.dict_modelfluxes
nsample, npar = self.chain_obj.flatchain.shape
source = data.name
if self.output_type == 'plot':
tau, agelog, nh, irlum, SB, BB, GA, TO, BBebv, GAebv = self.chain_obj.flatchain[
np.random.choice(nsample,
(self.out['realizations2plot'])), :].T
elif self.output_type == 'int_lums':
tau, agelog, nh, irlum, SB, BB, GA, TO, BBebv, GAebv = self.chain_obj.flatchain[
np.random.choice(nsample, (self.out['realizations2int'])), :].T
elif self.output_type == 'best_fit':
tau, agelog, nh, irlum, SB, BB, GA, TO, BBebv, GAebv = self.best_fit_pars
age = 10**agelog
self.all_nus_rest = np.arange(11.5, 16, 0.001)
for g in range(len(tau)):
# Pick dictionary key-values, nearest to the MCMC- parameter values
irlum_dct = model.pick_STARBURST_template(irlum[g], irlum_dict)
nh_dct = model.pick_TORUS_template(nh[g], nh_dict)
ebvbbb_dct = model.pick_BBB_template(BBebv[g], BBebv_dict)
gal_do.nearest_par2dict(tau[g], age[g], GAebv[g])
tau_dct, age_dct, ebvg_dct = gal_do.t, gal_do.a, gal_do.e
#Produce model fluxes at all_nus_rest for plotting, through interpolation
all_gal_nus, gal_Fnus = GALAXYFdict[tau_dct, age_dct, ebvg_dct]
GAinterp = scipy.interpolate.interp1d(all_gal_nus,
gal_Fnus,
bounds_error=False,
fill_value=0.)
all_gal_Fnus = GAinterp(self.all_nus_rest)
all_sb_nus, sb_Fnus = STARBURSTFdict[irlum_dct]
SBinterp = scipy.interpolate.interp1d(all_sb_nus,
sb_Fnus,
bounds_error=False,
fill_value=0.)
all_sb_Fnus = SBinterp(self.all_nus_rest)
all_bbb_nus, bbb_Fnus = BBBFdict[ebvbbb_dct]
BBinterp = scipy.interpolate.interp1d(all_bbb_nus,
bbb_Fnus,
bounds_error=False,
fill_value=0.)
all_bbb_Fnus = BBinterp(self.all_nus_rest)
all_bbb_nus, bbb_Fnus_deredd = BBBFdict['0.0']
BBderedinterp = scipy.interpolate.interp1d(all_bbb_nus,
bbb_Fnus_deredd,
bounds_error=False,
fill_value=0.)
all_bbb_Fnus_deredd = BBderedinterp(self.all_nus_rest)
all_tor_nus, tor_Fnus = TORUSFdict[nh_dct]
TOinterp = scipy.interpolate.interp1d(all_tor_nus,
np.log10(tor_Fnus),
bounds_error=False,
fill_value=0.)
all_tor_Fnus = 10**(TOinterp(self.all_nus_rest))
if self.output_type == 'plot':
par2 = tau[g], agelog[g], nh[g], irlum[g], SB[g], BB[g], GA[
g], TO[g], BBebv[g], GAebv[g]
filtered_modelpoints, _, _ = parspace.ymodel(
data.nus, data.z, data.dictkey_arrays,
data.dict_modelfluxes, *par2)
#Using the costumized normalization
SBFnu = (all_sb_Fnus / 1e20) * 10**float(SB[g])
BBFnu = (all_bbb_Fnus / 1e60) * 10**float(BB[g])
GAFnu = (all_gal_Fnus / 1e18) * 10**float(GA[g])
TOFnu = (all_tor_Fnus / 1e-40) * 10**float(TO[g])
BBFnu_deredd = (all_bbb_Fnus_deredd / 1e60) * 10**float(BB[g])
TOTALFnu = SBFnu + BBFnu + GAFnu + TOFnu
#Append to the list for all realizations
SBFnu_list.append(SBFnu)
BBFnu_list.append(BBFnu)
GAFnu_list.append(GAFnu)
TOFnu_list.append(TOFnu)
TOTALFnu_list.append(TOTALFnu)
BBFnu_deredd_list.append(BBFnu_deredd)
#Only if SED plotting: do the same with the modelled flux values at each data point
if self.output_type == 'plot':
filtered_modelpoints_list.append(filtered_modelpoints)
#Convert lists into Numpy arrays
SBFnu_array = np.array(SBFnu_list)
BBFnu_array = np.array(BBFnu_list)
GAFnu_array = np.array(GAFnu_list)
TOFnu_array = np.array(TOFnu_list)
TOTALFnu_array = np.array(TOTALFnu_list)
BBFnu_array_deredd = np.array(BBFnu_deredd_list)
#Put them all together to transport
FLUXES4plotting = (SBFnu_array, BBFnu_array, GAFnu_array, TOFnu_array,
TOTALFnu_array, BBFnu_array_deredd)
#Convert Fluxes to nuLnu
self.nuLnus4plotting = self.FLUXES2nuLnu_4plotting(
self.all_nus_rest, FLUXES4plotting, data.z)
#Only if SED plotting:
if self.output_type == 'plot':
filtered_modelpoints = np.array(filtered_modelpoints_list)
distance = model.z2Dlum(data.z)
lumfactor = (4. * math.pi * distance**2.)
self.filtered_modelpoints_nuLnu = (filtered_modelpoints *
lumfactor * 10**(data.nus))
#Only if calculating integrated luminosities:
elif self.output_type == 'int_lums':
self.int_lums = np.log10(
self.integrated_luminosities(self.out, self.all_nus_rest,
self.nuLnus4plotting))
def fluxes(self, data):
"""
This is the main function of the class.
"""
self.chain_obj.props()
SBFnu_list = []
BBFnu_list = []
GAFnu_list = []
TOFnu_list = []
TOTALFnu_list = []
BBFnu_deredd_list = []
if self.output_type == 'plot':
filtered_modelpoints_list = []
gal_obj, sb_obj, tor_obj, bbb_obj = data.dictkey_arrays
# Take the 4 dictionaries for plotting. Dicts are described in DICTIONARIES_AGNfitter.py
_, _, _, _, STARBURSTFdict, BBBFdict, GALAXYFdict, TORUSFdict, _, _ = data.dict_modelfluxes
nsample, npar = self.chain_obj.flatchain.shape
source = data.name
if self.output_type == 'plot':
par = self.chain_obj.flatchain[np.random.choice(
nsample, (self.out['realizations2plot'])), :] #.T
elif self.output_type == 'int_lums':
par = self.chain_obj.flatchain[np.random.choice(
nsample, (self.out['realizations2int'])), :] #.T
elif self.output_type == 'best_fit':
par = self.chain_obj.best_fit_pars
if self.models['BBB'] == 'D12_S' or self.models['BBB'] == 'D12_K':
self.all_nus_rest = np.arange(11.5, 19, 0.001)
else:
self.all_nus_rest = np.arange(11.5, 16.2, 0.001)
if self.output_type == 'plot' or self.output_type == 'int_lums':
for g in range(self.out['realizations2plot']):
## Pick dictionary key-values, nearest to the MCMC- parameter values
## Use pick_nD if model has more than one parameter,
## and pick_1D if it has only one.
gal_obj.pick_nD(par[g][self.P['idxs'][0]:self.P['idxs'][1]])
tor_obj.pick_1D(par[g][self.P['idxs'][2]:self.P['idxs'][3]])
if len(sb_obj.par_names) == 1:
sb_obj.pick_1D(par[g][self.P['idxs'][1]:self.P['idxs'][2]])
all_sb_nus, sb_Fnus = STARBURSTFdict[
sb_obj.matched_parkeys]
else:
sb_obj.pick_nD(par[g][self.P['idxs'][1]:self.P['idxs'][2]])
all_sb_nus, sb_Fnus = STARBURSTFdict[tuple(
sb_obj.matched_parkeys)]
if len(bbb_obj.par_names) == 1:
GA, SB, TO, BB = par[g][-4:]
bbb_obj.pick_1D(
par[g][self.P['idxs'][3]:self.P['idxs'][4]])
all_bbb_nus, bbb_Fnus = BBBFdict[bbb_obj.matched_parkeys]
#print bbb_Fnus
else:
GA, SB, TO = par[g][-3:]
BB = 0.
bbb_obj.pick_nD(
par[g][self.P['idxs'][3]:self.P['idxs'][4]])
all_bbb_nus, bbb_Fnus = BBBFdict[tuple(
bbb_obj.matched_parkeys)]
#Produce model fluxes at all_nus_rest for plotting, through interpolation
all_gal_nus, gal_Fnus = GALAXYFdict[tuple(
gal_obj.matched_parkeys)]
GAinterp = scipy.interpolate.interp1d(all_gal_nus,
gal_Fnus,
bounds_error=False,
fill_value=0.)
all_gal_Fnus = GAinterp(self.all_nus_rest)
SBinterp = scipy.interpolate.interp1d(all_sb_nus,
sb_Fnus,
bounds_error=False,
fill_value=0.)
all_sb_Fnus = SBinterp(self.all_nus_rest)
BBinterp = scipy.interpolate.interp1d(all_bbb_nus,
bbb_Fnus,
bounds_error=False,
fill_value=0.)
all_bbb_Fnus = BBinterp(self.all_nus_rest)
### Plot dereddened
if len(bbb_obj.par_names) == 1:
all_bbb_nus, bbb_Fnus_deredd = BBBFdict['0.0']
BBderedinterp = scipy.interpolate.interp1d(
all_bbb_nus,
bbb_Fnus_deredd,
bounds_error=False,
fill_value=0.)
all_bbb_Fnus_deredd = BBderedinterp(self.all_nus_rest)
else:
all_bbb_Fnus_deredd = all_bbb_Fnus
all_tor_nus, tor_Fnus = TORUSFdict[tor_obj.matched_parkeys]
TOinterp = scipy.interpolate.interp1d(all_tor_nus,
np.log10(tor_Fnus),
bounds_error=False,
fill_value=0.)
all_tor_Fnus = 10**(TOinterp(self.all_nus_rest))
all_tor_Fnus[self.all_nus_rest > 16] = 0
if self.output_type == 'plot':
par2 = par[g]
#print data.dictkey_arrays
filtered_modelpoints, _, _ = parspace.ymodel(
data.nus, data.z, data.dlum, data.dictkey_arrays,
data.dict_modelfluxes, self.P, *par2)
#print filtered_modelpoints
#Using the costumized normalization
SBFnu = (all_sb_Fnus / 1e20) * 10**float(SB)
BBFnu = (all_bbb_Fnus / 1e60) * 10**float(
BB) # * (data.dlum)**2
GAFnu = (all_gal_Fnus / 1e18) * 10**float(GA)
TOFnu = (all_tor_Fnus / 1e-40) * 10**float(TO)
BBFnu_deredd = (all_bbb_Fnus_deredd / 1e60) * 10**float(BB)
TOTALFnu = SBFnu + BBFnu + GAFnu + TOFnu
#Append to the list for all realizations
SBFnu_list.append(SBFnu)
BBFnu_list.append(BBFnu)
GAFnu_list.append(GAFnu)
TOFnu_list.append(TOFnu)
TOTALFnu_list.append(TOTALFnu)
BBFnu_deredd_list.append(BBFnu_deredd)
#Only if SED plotting: do the same with the modelled flux values at each data point
if self.output_type == 'plot':
filtered_modelpoints_list.append(filtered_modelpoints)
#Convert lists into Numpy arrays
SBFnu_array = np.array(SBFnu_list)
BBFnu_array = np.array(BBFnu_list)
GAFnu_array = np.array(GAFnu_list)
TOFnu_array = np.array(TOFnu_list)
TOTALFnu_array = np.array(TOTALFnu_list)
BBFnu_array_deredd = np.array(BBFnu_deredd_list)
#Put them all together to transport
FLUXES4plotting = (SBFnu_array, BBFnu_array, GAFnu_array,
TOFnu_array, TOTALFnu_array, BBFnu_array_deredd)
#Convert Fluxes to nuLnu
self.nuLnus4plotting = self.FLUXES2nuLnu_4plotting(
self.all_nus_rest, FLUXES4plotting, data.z)
elif self.output_type == 'best_fit':
## Pick dictionary key-values, nearest to the MCMC- parameter values
## Use pick_nD if model has more than one parameter,
## and pick_1D if it has only one.
gal_obj.pick_nD(par[self.P['idxs'][0]:self.P['idxs'][1]])
tor_obj.pick_1D(par[self.P['idxs'][2]:self.P['idxs'][3]])
if len(sb_obj.par_names) == 1:
sb_obj.pick_1D(par[self.P['idxs'][1]:self.P['idxs'][2]])
all_sb_nus, sb_Fnus = STARBURSTFdict[sb_obj.matched_parkeys]
else:
sb_obj.pick_nD(par[self.P['idxs'][1]:self.P['idxs'][2]])
all_sb_nus, sb_Fnus = STARBURSTFdict[tuple(
sb_obj.matched_parkeys)]
if len(bbb_obj.par_names) == 1:
GA, SB, TO, BB = par[-4:]
bbb_obj.pick_1D(par[self.P['idxs'][3]:self.P['idxs'][4]])
all_bbb_nus, bbb_Fnus = BBBFdict[bbb_obj.matched_parkeys]
#print bbb_Fnus
else:
GA, SB, TO = par[-3:]
BB = 0.
bbb_obj.pick_nD(par[self.P['idxs'][3]:self.P['idxs'][4]])
all_bbb_nus, bbb_Fnus = BBBFdict[tuple(
bbb_obj.matched_parkeys)]
#Produce model fluxes at all_nus_rest for plotting, through interpolation
all_gal_nus, gal_Fnus = GALAXYFdict[tuple(gal_obj.matched_parkeys)]
GAinterp = scipy.interpolate.interp1d(all_gal_nus,
gal_Fnus,
bounds_error=False,
fill_value=0.)
all_gal_Fnus = GAinterp(self.all_nus_rest)
SBinterp = scipy.interpolate.interp1d(all_sb_nus,
sb_Fnus,
bounds_error=False,
fill_value=0.)
all_sb_Fnus = SBinterp(self.all_nus_rest)
BBinterp = scipy.interpolate.interp1d(all_bbb_nus,
bbb_Fnus,
bounds_error=False,
fill_value=0.)
all_bbb_Fnus = BBinterp(self.all_nus_rest)
### Plot dereddened
if len(bbb_obj.par_names) == 1:
all_bbb_nus, bbb_Fnus_deredd = BBBFdict['0.0']
BBderedinterp = scipy.interpolate.interp1d(all_bbb_nus,
bbb_Fnus_deredd,
bounds_error=False,
fill_value=0.)
all_bbb_Fnus_deredd = BBderedinterp(self.all_nus_rest)
else:
all_bbb_Fnus_deredd = all_bbb_Fnus
all_tor_nus, tor_Fnus = TORUSFdict[tor_obj.matched_parkeys]
TOinterp = scipy.interpolate.interp1d(all_tor_nus,
np.log10(tor_Fnus),
bounds_error=False,
fill_value=0.)
all_tor_Fnus = 10**(TOinterp(self.all_nus_rest))
all_tor_Fnus[self.all_nus_rest > 16] = 0
par2 = par
#print data.dictkey_arrays
filtered_modelpoints, _, _ = parspace.ymodel(
data.nus, data.z, data.dlum, data.dictkey_arrays,
data.dict_modelfluxes, self.P, *par2)
#print filtered_modelpoints
#Using the costumized normalization
SBFnu = (all_sb_Fnus / 1e20) * 10**float(SB)
BBFnu = (all_bbb_Fnus / 1e60) * 10**float(BB) # * (data.dlum)**2
GAFnu = (all_gal_Fnus / 1e18) * 10**float(GA)
TOFnu = (all_tor_Fnus / 1e-40) * 10**float(TO)
BBFnu_deredd = (all_bbb_Fnus_deredd / 1e60) * 10**float(BB)
TOTALFnu = SBFnu + BBFnu + GAFnu + TOFnu
#Put them all together to transport
FLUXES4plotting = (SBFnu, BBFnu, GAFnu, TOFnu, TOTALFnu,
BBFnu_deredd)
#Convert Fluxes to nuLnu
self.nuLnus4plotting = self.FLUXES2nuLnu_4plotting(
self.all_nus_rest, FLUXES4plotting, data.z)
#Only if SED plotting:
if self.output_type == 'plot':
filtered_modelpoints = np.array(filtered_modelpoints_list)
distance = model.z2Dlum(data.z)
lumfactor = (4. * math.pi * distance**2.)
self.filtered_modelpoints_nuLnu = (filtered_modelpoints *
lumfactor * 10**(data.nus))
#print self.filtered_modelpoints_nuLnu
#print 10**(data.nus)
#Only if calculating integrated luminosities:
elif self.output_type == 'int_lums':
self.int_lums = np.log10(
self.integrated_luminosities(self.out, self.all_nus_rest,
self.nuLnus4plotting))
elif self.output_type == 'best_fit':
distance = model.z2Dlum(data.z)
lumfactor = (4. * math.pi * distance**2.)
self.filtered_modelpoints_nuLnu = (filtered_modelpoints *
lumfactor * 10**(data.nus))
def construct_dictionaryarray_filtered(self, z, filterdict,path):
"""
Construct the dictionaries of fluxes at bands (to compare to data),
and dictionaries of fluxes over the whole spectrum, for plotting.
"""
GALAXYFdict_filtered = dict()
GALAXY_SFRdict = dict()
STARBURSTFdict_filtered = dict()
BBBFdict_filtered = dict()
TORUSFdict_filtered = dict()
GALAXYFdict_4plot = dict()
STARBURSTFdict_4plot = dict()
BBBFdict_4plot = dict()
TORUSFdict_4plot = dict()
#OPENING TEMPLATES AND BUILDING DICTIONARIES
#Call object containing all galaxy models
galaxy_object = cPickle.load(file(path + 'models/GALAXY/bc03_275templates.pickle', 'rb'))
_, ageidx, tauidx, _, _,_ = np.shape(galaxy_object.SED)
#Construct dictionaries
for taui in range(tauidx):
for agei in range(ageidx):
t1= time.time()
gal_wl, gal_Fwl = galaxy_object.wave, galaxy_object.SED[:,agei,taui,:,:,:].squeeze()
gal_nus= gal_wl.to(u.Hz, equivalencies=u.spectral())[::-1]#invert
gal_Fnu= (gal_Fwl * 3.34e-19 * gal_wl**2.)[::-1]
gal_SFR= galaxy_object.SFR[:,agei,taui,:,:].squeeze()
GALAXY_SFRdict[str(galaxy_object.tau.value[taui]),str(galaxy_object.tg.value[agei])] = gal_SFR
for EBV_gal in self.ebvgal_array:
#Apply reddening
gal_nu, gal_Fnu_red = model.GALAXYred_Calzetti(gal_nus.value[0:len(gal_nus):3], gal_Fnu.value[0:len(gal_nus):3], EBV_gal)
GALAXYFdict_4plot[str(galaxy_object.tau.value[taui]),str(galaxy_object.tg.value[agei]), str(EBV_gal)] = \
np.log10(gal_nu), gal_Fnu_red
#Projection of filter curves on models
bands, gal_Fnu_filtered = model.filters1(np.log10(gal_nu), gal_Fnu_red, filterdict, z)
GALAXYFdict_filtered[str(galaxy_object.tau.value[taui]),str(galaxy_object.tg.value[agei]), str(EBV_gal)] = \
bands, gal_Fnu_filtered
#Call object containing all starburst models
starburst_object = cPickle.load(file(path + 'models/STARBURST/dalehelou_charyelbaz_v1.pickle', 'rb'))
irlumidx = len(starburst_object.SED)
#Construct dictionaries
for irlumi in range(irlumidx):
sb_nu0, sb_Fnu0 = starburst_object.wave[irlumi], starburst_object.SED[irlumi].squeeze()
STARBURSTFdict_4plot[str(starburst_object.irlum[irlumi])] = sb_nu0, sb_Fnu0
bands, sb_Fnu_filtered = model.filters1(sb_nu0, sb_Fnu0, filterdict, z)
STARBURSTFdict_filtered[str(starburst_object.irlum[irlumi])] = bands, sb_Fnu_filtered
if np.amax(sb_Fnu_filtered) == 0:
print 'Error: something is wrong in the calculation of STARBURST flux'
#No object to call since bbb is only one model
bbb_object = cPickle.load(file(path + 'models/BBB/richards.pickle', 'rb'))
bbb_nu, bbb_Fnu = bbb_object.wave, bbb_object.SED.squeeze()
#Construct dictionaries
for EBV_bbb in self.ebvbbb_array:
bbb_nu0, bbb_Fnu_red = model.BBBred_Prevot(bbb_nu, bbb_Fnu, EBV_bbb, z )
BBBFdict_4plot[str(EBV_bbb)] =bbb_nu0, bbb_Fnu_red
bands, bbb_Fnu_filtered = model.filters1(bbb_nu0, bbb_Fnu_red, filterdict,z)
BBBFdict_filtered[str(EBV_bbb)] = bands, bbb_Fnu_filtered
if np.amax(bbb_Fnu_filtered) == 0:
print 'Error: something is wrong in the calculation of BBB flux'
#Call object containing all torus models
torus_object = cPickle.load(file(path + 'models/TORUS/silva_v1.pickle', 'rb'))
nhidx=len(torus_object.SED)
#Construct dictionaries
for nhi in range(nhidx):
tor_nu0, tor_Fnu0 = torus_object.wave[nhi], torus_object.SED[nhi].squeeze()
TORUSFdict_4plot[str(torus_object.nh[nhi])] = tor_nu0, tor_Fnu0
bands, tor_Fnu_filtered = model.filters1(tor_nu0, tor_Fnu0, filterdict, z)
TORUSFdict_filtered[str(torus_object.nh[nhi])] = bands, tor_Fnu_filtered
if np.amax(tor_Fnu_filtered) == 0:
print 'Error: something is wrong in the calculation of TORUS flux'
return STARBURSTFdict_filtered , BBBFdict_filtered, GALAXYFdict_filtered, TORUSFdict_filtered, \
STARBURSTFdict_4plot , BBBFdict_4plot, GALAXYFdict_4plot, TORUSFdict_4plot,GALAXY_SFRdict
def ymodel(data_nus, z, dict_modelsfiles, dict_modelfluxes, *par):
"""
This function constructs the model from the parameter values
## inputs:
- v: frequency
- catalog file name
- sourcelines
## output:
- dictionary P with all parameter characteristics
## comments:
-
## bugs:
"""
all_tau, all_age, all_nh, all_irlum, filename_0_galaxy, filename_0_starburst, filename_0_torus = dict_modelsfiles
STARBURSTFdict , BBBFdict, GALAXYFdict, TORUSFdict, EBVbbb_array, EBVgal_array= dict_modelfluxes
# Call parameters from Emcee
tau, agelog, nh, irlum, SB ,BB, GA,TO, BBebv, GAebv= par[0:10]
age = 10**agelog
# Pick templates for physical parameters
SB_filename = model.pick_STARBURST_template(irlum, filename_0_starburst, all_irlum)
GA_filename = model.pick_GALAXY_template(tau, age, filename_0_galaxy, all_tau, all_age)
TOR_filename = model.pick_TORUS_template(nh, all_nh, filename_0_torus)
BB_filename = 'models/BBB/richardsbbb.dat'
EBV_bbb_0 = model.pick_EBV_grid(EBVbbb_array, BBebv)
EBV_bbb = ( str(int(EBV_bbb_0)) if float(EBV_bbb_0).is_integer() else str(EBV_bbb_0))
EBV_gal_0 = model.pick_EBV_grid(EBVgal_array,GAebv)
EBV_gal = ( str(int(EBV_gal_0)) if float(EBV_gal_0).is_integer() else str(EBV_gal_0))
try:
bands, gal_Fnu = GALAXYFdict[GA_filename, EBV_gal]
bands, sb_Fnu= STARBURSTFdict[SB_filename]
bands, bbb_Fnu = BBBFdict[BB_filename, EBV_bbb]
bands, tor_Fnu= TORUSFdict[TOR_filename]
except ValueError:
print 'Error: Dictionary does not contain TORUS file:'+TOR_filename
sb_Fnu *= 10**(SB)*1e-20#e50
bbb_Fnu *= 10**(BB)*1e-60#e90
gal_Fnu *= 10**(GA)*1e-18
tor_Fnu *= 10**(TO)*1e40
# Sum components
lum = sb_Fnu+ bbb_Fnu+ gal_Fnu + tor_Fnu
lum = lum.reshape((np.size(lum),))
return lum
def fluxes(self, data):
"""
This is the main function of the class.
"""
self.chain_obj.props()
SBFnu_list = []
BBFnu_list = []
GAFnu_list= []
TOFnu_list = []
TOTALFnu_list = []
BBFnu_deredd_list = []
if self.output_type == 'plot':
filtered_modelpoints_list = []
gal_do, irlum_dict, nh_dict, BBebv_dict,_ = data.dictkey_arrays
# Take the last 4 dictionaries, which are for plotting. (the first 4 were at bands)
_,_,_,_,STARBURSTFdict , BBBFdict, GALAXYFdict, TORUSFdict,_= data.dict_modelfluxes
nsample, npar = self.chain_obj.flatchain.shape
source = data.name
if self.output_type == 'plot':
tau, agelog, nh, irlum, SB ,BB, GA,TO, BBebv, GAebv= self.chain_obj.flatchain[np.random.choice(nsample, (self.out['realizations2plot'])),:].T
elif self.output_type == 'int_lums':
tau, agelog, nh, irlum, SB ,BB, GA,TO, BBebv, GAebv= self.chain_obj.flatchain[np.random.choice(nsample, (self.out['realizations2int'])),:].T
elif self.output_type == 'best_fit':
tau, agelog, nh, irlum, SB ,BB, GA,TO, BBebv, GAebv= self.best_fit_pars
age = 10**agelog
self.all_nus_rest = np.arange(11.5, 16, 0.001)
for g in range(len(tau)):
# Pick dictionary key-values, nearest to the MCMC- parameter values
irlum_dct = model.pick_STARBURST_template(irlum[g], irlum_dict)
nh_dct = model.pick_TORUS_template(nh[g], nh_dict)
ebvbbb_dct = model.pick_BBB_template(BBebv[g], BBebv_dict)
gal_do.nearest_par2dict(tau[g], age[g], GAebv[g])
tau_dct, age_dct, ebvg_dct=gal_do.t, gal_do.a,gal_do.e
#Produce model fluxes at all_nus_rest for plotting, through interpolation
all_gal_nus, gal_Fnus = GALAXYFdict[tau_dct, age_dct,ebvg_dct]
GAinterp = scipy.interpolate.interp1d(all_gal_nus, gal_Fnus, bounds_error=False, fill_value=0.)
all_gal_Fnus = GAinterp(self.all_nus_rest)
all_sb_nus, sb_Fnus= STARBURSTFdict[irlum_dct]
SBinterp = scipy.interpolate.interp1d(all_sb_nus, sb_Fnus, bounds_error=False, fill_value=0.)
all_sb_Fnus = SBinterp(self.all_nus_rest)
all_bbb_nus, bbb_Fnus = BBBFdict[ebvbbb_dct]
BBinterp = scipy.interpolate.interp1d(all_bbb_nus, bbb_Fnus, bounds_error=False, fill_value=0.)
all_bbb_Fnus = BBinterp(self.all_nus_rest)
all_bbb_nus, bbb_Fnus_deredd = BBBFdict['0.0']
BBderedinterp = scipy.interpolate.interp1d(all_bbb_nus, bbb_Fnus_deredd, bounds_error=False, fill_value=0.)
all_bbb_Fnus_deredd = BBderedinterp(self.all_nus_rest)
all_tor_nus, tor_Fnus= TORUSFdict[nh_dct]
TOinterp = scipy.interpolate.interp1d(all_tor_nus, np.log10(tor_Fnus), bounds_error=False, fill_value=0.)
all_tor_Fnus = 10**(TOinterp(self.all_nus_rest))
if self.output_type == 'plot':
par2 = tau[g], agelog[g], nh[g], irlum[g], SB[g] ,BB[g], GA[g] ,TO[g], BBebv[g], GAebv[g]
filtered_modelpoints, _, _ = parspace.ymodel(data.nus,data.z, data.dictkey_arrays, data.dict_modelfluxes, *par2)
#Using the costumized normalization
SBFnu = (all_sb_Fnus /1e20) *10**float(SB[g])
BBFnu = (all_bbb_Fnus /1e60) * 10**float(BB[g])
GAFnu = (all_gal_Fnus/ 1e18) * 10**float(GA[g])
TOFnu = (all_tor_Fnus/ 1e-40) * 10**float(TO[g])
BBFnu_deredd = (all_bbb_Fnus_deredd /1e60) * 10**float(BB[g])
TOTALFnu = SBFnu + BBFnu + GAFnu + TOFnu
#Append to the list for all realizations
SBFnu_list.append(SBFnu)
BBFnu_list.append(BBFnu)
GAFnu_list.append(GAFnu)
TOFnu_list.append(TOFnu)
TOTALFnu_list.append(TOTALFnu)
BBFnu_deredd_list.append(BBFnu_deredd)
#Only if SED plotting: do the same with the modelled flux values at each data point
if self.output_type == 'plot':
filtered_modelpoints_list.append(filtered_modelpoints)
#Convert lists into Numpy arrays
SBFnu_array = np.array(SBFnu_list)
BBFnu_array = np.array(BBFnu_list)
GAFnu_array = np.array(GAFnu_list)
TOFnu_array = np.array(TOFnu_list)
TOTALFnu_array = np.array(TOTALFnu_list)
BBFnu_array_deredd = np.array(BBFnu_deredd_list)
#Put them all together to transport
FLUXES4plotting = (SBFnu_array, BBFnu_array, GAFnu_array, TOFnu_array, TOTALFnu_array,BBFnu_array_deredd)
#Convert Fluxes to nuLnu
self.nuLnus4plotting = self.FLUXES2nuLnu_4plotting(self.all_nus_rest, FLUXES4plotting, data.z)
#Only if SED plotting:
if self.output_type == 'plot':
filtered_modelpoints = np.array(filtered_modelpoints_list)
distance= model.z2Dlum(data.z)
lumfactor = (4. * math.pi * distance**2.)
self.filtered_modelpoints_nuLnu = (filtered_modelpoints *lumfactor* 10**(data.nus))
#Only if calculating integrated luminosities:
elif self.output_type == 'int_lums':
self.int_lums= np.log10(self.integrated_luminosities(self.out ,self.all_nus_rest, self.nuLnus4plotting))
def construct_dictionaryarray_filtered(self, z, filterdict, path):
"""
Construct the dictionaries of fluxes at bands (to compare to data),
and dictionaries of fluxes over the whole spectrum, for plotting.
"""
GALAXYFdict_filtered = dict()
GALAXY_SFRdict = dict()
STARBURSTFdict_filtered = dict()
BBBFdict_filtered = dict()
TORUSFdict_filtered = dict()
GALAXYFdict_4plot = dict()
STARBURSTFdict_4plot = dict()
BBBFdict_4plot = dict()
TORUSFdict_4plot = dict()
#OPENING TEMPLATES AND BUILDING DICTIONARIES
#Call object containing all galaxy models
galaxy_object = cPickle.load(
file(path + 'models/GALAXY/bc03_275templates.pickle', 'rb'))
_, ageidx, tauidx, _, _, _ = np.shape(galaxy_object.SED)
#Construct dictionaries
for taui in range(tauidx):
for agei in range(ageidx):
t1 = time.time()
gal_wl, gal_Fwl = galaxy_object.wave, galaxy_object.SED[:,
agei,
taui, :, :, :].squeeze(
)
gal_nus = gal_wl.to(u.Hz,
equivalencies=u.spectral())[::-1] #invert
gal_Fnu = (gal_Fwl * 3.34e-19 * gal_wl**2.)[::-1]
gal_SFR = galaxy_object.SFR[:, agei, taui, :, :].squeeze()
GALAXY_SFRdict[str(galaxy_object.tau.value[taui]),
str(galaxy_object.tg.value[agei])] = gal_SFR
for EBV_gal in self.ebvgal_array:
#Apply reddening
gal_nu, gal_Fnu_red = model.GALAXYred_Calzetti(
gal_nus.value[0:len(gal_nus):3],
gal_Fnu.value[0:len(gal_nus):3], EBV_gal)
GALAXYFdict_4plot[str(galaxy_object.tau.value[taui]),str(galaxy_object.tg.value[agei]), str(EBV_gal)] = \
np.log10(gal_nu), gal_Fnu_red
#Projection of filter curves on models
bands, gal_Fnu_filtered = model.filters1(
np.log10(gal_nu), gal_Fnu_red, filterdict, z)
GALAXYFdict_filtered[str(galaxy_object.tau.value[taui]),str(galaxy_object.tg.value[agei]), str(EBV_gal)] = \
bands, gal_Fnu_filtered
#Call object containing all starburst models
starburst_object = cPickle.load(
file(path + 'models/STARBURST/dalehelou_charyelbaz_v1.pickle',
'rb'))
irlumidx = len(starburst_object.SED)
#Construct dictionaries
for irlumi in range(irlumidx):
sb_nu0, sb_Fnu0 = starburst_object.wave[
irlumi], starburst_object.SED[irlumi].squeeze()
STARBURSTFdict_4plot[str(
starburst_object.irlum[irlumi])] = sb_nu0, sb_Fnu0
bands, sb_Fnu_filtered = model.filters1(sb_nu0, sb_Fnu0,
filterdict, z)
STARBURSTFdict_filtered[str(
starburst_object.irlum[irlumi])] = bands, sb_Fnu_filtered
if np.amax(sb_Fnu_filtered) == 0:
print 'Error: something is wrong in the calculation of STARBURST flux'
#No object to call since bbb is only one model
bbb_object = cPickle.load(
file(path + 'models/BBB/richards.pickle', 'rb'))
bbb_nu, bbb_Fnu = bbb_object.wave, bbb_object.SED.squeeze()
#Construct dictionaries
for EBV_bbb in self.ebvbbb_array:
bbb_nu0, bbb_Fnu_red = model.BBBred_Prevot(bbb_nu, bbb_Fnu,
EBV_bbb, z)
BBBFdict_4plot[str(EBV_bbb)] = bbb_nu0, bbb_Fnu_red
bands, bbb_Fnu_filtered = model.filters1(bbb_nu0, bbb_Fnu_red,
filterdict, z)
BBBFdict_filtered[str(EBV_bbb)] = bands, bbb_Fnu_filtered
if np.amax(bbb_Fnu_filtered) == 0:
print 'Error: something is wrong in the calculation of BBB flux'
#Call object containing all torus models
torus_object = cPickle.load(
file(path + 'models/TORUS/silva_v1.pickle', 'rb'))
nhidx = len(torus_object.SED)
#Construct dictionaries
for nhi in range(nhidx):
tor_nu0, tor_Fnu0 = torus_object.wave[nhi], torus_object.SED[
nhi].squeeze()
TORUSFdict_4plot[str(torus_object.nh[nhi])] = tor_nu0, tor_Fnu0
bands, tor_Fnu_filtered = model.filters1(tor_nu0, tor_Fnu0,
filterdict, z)
TORUSFdict_filtered[str(
torus_object.nh[nhi])] = bands, tor_Fnu_filtered
if np.amax(tor_Fnu_filtered) == 0:
print 'Error: something is wrong in the calculation of TORUS flux'
return STARBURSTFdict_filtered , BBBFdict_filtered, GALAXYFdict_filtered, TORUSFdict_filtered, \
STARBURSTFdict_4plot , BBBFdict_4plot, GALAXYFdict_4plot, TORUSFdict_4plot,GALAXY_SFRdict
def fluxes_arrays(data_nus, catalog, sourceline, dict_modelsfiles, filterdict, chain, Nrealizations, path, dict_modelfluxes, mock_input):
"""
This function constructs the luminosities arrays for many realizations from the parameter values
## inputs:
- v: frequency
- catalog file name
- sourcelines
## output:
- dictionary P with all parameter characteristics
"""
#LIST OF OUTPUT
SBFnu_list = []
BBFnu_list = []
GAFnu_list= []
TOFnu_list = []
TOTALFnu_list = []
BBFnu_deredd_list = []
filtered_modelpoints_list = []
STARBURSTFdict , BBBFdict, GALAXYFdict, TORUSFdict, EBVbbb_array, EBVgal_array = dict_modelfluxes
all_tau, all_age, all_nh, all_irlum, filename_0_galaxy, filename_0_starburst, filename_0_torus = dict_modelsfiles
nsample, npar = chain.shape
source = NAME(catalog, sourceline)
#CALL PARAMETERS FROM INPUT
itau, iage, inh, iirlum, iSB ,iBB, iGA ,iTO, iBBebv, iGAebv= mock_input[sourceline] #calling parameter
#CALL PARAMETERS OF OUTPUT
tau, agelog, nh, irlum, SB ,BB, GA,TO, BBebv0, GAebv0= [ chain[:,i] for i in range(npar)] #calling parameters
z = REDSHIFT(catalog, sourceline)
age = 10**agelog
agelog = np.log10(age)
iagelog = np.log10(iage)
#LEFT PLOT
for inp in range(1):
SB_filename = path + model.pick_STARBURST_template(iirlum, filename_0_starburst, all_irlum)
GA_filename = path + model.pick_GALAXY_template(itau, iage, filename_0_galaxy, all_tau, all_age)
TO_filename = path + model.pick_TORUS_template(inh, all_nh, filename_0_torus)
BB_filename = path + model.pick_BBB_template()
all_model_nus = np.arange(12, 16, 0.001)#np.log10(dicts.stack_all_model_nus(filename_0_galaxy, filename_0_starburst, filename_0_torus, z, path ))
gal_nu, gal_nored_Fnu = model.GALAXY_read_4plotting( GA_filename, all_model_nus)
gal_nu, gal_Fnu_red = model.GALAXY_nf2( gal_nu, gal_nored_Fnu, iGAebv )
all_gal_nus, all_gal_Fnus =gal_nu, gal_Fnu_red
sb_nu0, sb_Fnu0 = model.STARBURST_read_4plotting(SB_filename, all_model_nus)
all_sb_nus, all_sb_Fnus = sb_nu0, sb_Fnu0
bbb_nu, bbb_nored_Fnu = model.BBB_read_4plotting(BB_filename, all_model_nus)
all_bbb_nus, all_bbb_Fnus = model.BBB_nf2(bbb_nu, bbb_nored_Fnu, iBBebv, z )
all_bbb_nus, all_bbb_Fnus_deredd =all_bbb_nus, bbb_nored_Fnu
tor_nu0, tor_Fnu0 = model.TORUS_read_4plotting(TO_filename, z, all_model_nus)
all_tor_nus, all_tor_Fnus = tor_nu0, tor_Fnu0
par_input = itau, iagelog, inh, iirlum, iSB ,iBB, iGA ,iTO, iBBebv, iGAebv
ifiltered_modelpoints = parspace.ymodel(data_nus, z, dict_modelsfiles, dict_modelfluxes, *par_input)
if len(all_gal_nus)==len(all_sb_nus) and len(all_sb_nus)==len(all_bbb_nus) and len(all_tor_nus)==len(all_bbb_nus) :
nu= all_gal_nus
all_sb_Fnus_norm = all_sb_Fnus /1e20
all_bbb_Fnus_norm = all_bbb_Fnus / 1e60
all_gal_Fnus_norm = all_gal_Fnus/ 1e18
all_tor_Fnus_norm = all_tor_Fnus/ 1e-40
all_bbb_Fnus_deredd_norm = all_bbb_Fnus_deredd / 1e60
iSBFnu = all_sb_Fnus_norm *10**float(iSB)
iBBFnu = all_bbb_Fnus_norm * 10**float(iBB)
iGAFnu = all_gal_Fnus_norm * 10**float(iGA)
iTOFnu = all_tor_Fnus_norm * 10**float(iTO)# /(1+z)
iBBFnu_deredd = all_bbb_Fnus_deredd_norm* 10**float(iBB)
iTOTALFnu = iSBFnu + iBBFnu + iGAFnu + iTOFnu
#RIGHT PLOT
for gi in range(Nrealizations): #LOOP for a 100th part of the realizations
g= gi*(nsample/Nrealizations)
BBebv1 = model.pick_EBV_grid(EBVbbb_array, BBebv0[g])
BBebv2 = ( str(int(BBebv1)) if float(BBebv1).is_integer() else str(BBebv1))
GAebv1 = model.pick_EBV_grid(EBVgal_array,GAebv0[g])
GAebv2 = ( str(int(GAebv1)) if float(GAebv1).is_integer() else str(GAebv1))
SB_filename = path + model.pick_STARBURST_template(irlum[g], filename_0_starburst, all_irlum)
GA_filename = path + model.pick_GALAXY_template(tau[g], age[g], filename_0_galaxy, all_tau, all_age)
TO_filename = path + model.pick_TORUS_template(nh[g], all_nh, filename_0_torus)
BB_filename = path + model.pick_BBB_template()
all_model_nus = np.arange(12, 16, 0.001)#np.log10(dicts.stack_all_model_nus(filename_0_galaxy, filename_0_starburst, filename_0_torus, z, path ))
gal_nu, gal_nored_Fnu = model.GALAXY_read_4plotting( GA_filename, all_model_nus)
gal_nu, gal_Fnu_red = model.GALAXY_nf2( gal_nu, gal_nored_Fnu, float(GAebv2))
all_gal_nus, all_gal_Fnus =gal_nu, gal_Fnu_red
sb_nu0, sb_Fnu0 = model.STARBURST_read_4plotting(SB_filename, all_model_nus)
all_sb_nus, all_sb_Fnus = sb_nu0, sb_Fnu0
bbb_nu, bbb_nored_Fnu = model.BBB_read_4plotting(BB_filename, all_model_nus)
bbb_nu0, bbb_Fnu_red = model.BBB_nf2(bbb_nu, bbb_nored_Fnu, float(BBebv2), z )
all_bbb_nus, all_bbb_Fnus = bbb_nu0, bbb_Fnu_red
all_bbb_nus, all_bbb_Fnus_deredd = bbb_nu0, bbb_nored_Fnu
tor_nu0, tor_Fnu0 = model.TORUS_read_4plotting(TO_filename, z, all_model_nus)
all_tor_nus, all_tor_Fnus = tor_nu0, tor_Fnu0
par1 = tau[g], agelog[g], nh[g], irlum[g], SB[g] ,BB[g], GA[g] ,TO[g], float(BBebv2), float(GAebv2)
filtered_modelpoints = parspace.ymodel(data_nus, z, dict_modelsfiles, dict_modelfluxes, *par1)
if len(all_gal_nus)==len(all_sb_nus) and len(all_sb_nus)==len(all_bbb_nus) and len(all_tor_nus)==len(all_bbb_nus) :
nu= all_gal_nus
all_sb_Fnus_norm = all_sb_Fnus /1e20
all_bbb_Fnus_norm = all_bbb_Fnus / 1e60
all_gal_Fnus_norm = all_gal_Fnus/ 1e18
all_tor_Fnus_norm = all_tor_Fnus/ 1e-40
all_bbb_Fnus_deredd_norm = all_bbb_Fnus_deredd / 1e60
SBFnu = all_sb_Fnus_norm *10**float(SB[g])
BBFnu = all_bbb_Fnus_norm * 10**float(BB[g])
GAFnu = all_gal_Fnus_norm * 10**float(GA[g])
TOFnu = all_tor_Fnus_norm * 10**float(TO[g]) #/(1+z)
BBFnu_deredd = all_bbb_Fnus_deredd_norm* 10**float(BB[g])
TOTALFnu = SBFnu + BBFnu + GAFnu + TOFnu
SBFnu_list.append(SBFnu)
BBFnu_list.append(BBFnu)
GAFnu_list.append(GAFnu)
TOFnu_list.append(TOFnu)
TOTALFnu_list.append(TOTALFnu)
BBFnu_deredd_list.append(BBFnu_deredd)
filtered_modelpoints_list.append(filtered_modelpoints)
else:
print 'Error:'
print 'The frequencies in the MODELdict_plot dictionaries are not equal for all models and could not be added.'
print 'Check that the dictionary_plot.py stacks all frequencies (bands+galaxy+bbb+sb+torus) properly.'
SBFnu_array = np.array(SBFnu_list)
BBFnu_array = np.array(BBFnu_list)
GAFnu_array = np.array(GAFnu_list)
TOFnu_array = np.array(TOFnu_list)
TOTALFnu_array = np.array(TOTALFnu_list)
BBFnu_array_deredd = np.array(BBFnu_deredd_list)
filtered_modelpoints = np.array(filtered_modelpoints_list)
FLUXES4plotting = (SBFnu_array, BBFnu_array, GAFnu_array, TOFnu_array, TOTALFnu_array,BBFnu_array_deredd, iSBFnu, iBBFnu, iGAFnu, iTOFnu, iTOTALFnu,iBBFnu_deredd)
return all_model_nus, FLUXES4plotting, filtered_modelpoints, ifiltered_modelpoints
def PLOT_nr1(source, catalog, data_nus, data_flux, data_errors, z, all_nus, FLUXES4plotting, filtered_modelpoints, ifiltered_modelpoints, Nrealizations, mock_input):
# Two subplots, unpack the output array immediately
data_nus_obs = 10**data_nus
data_nus_rest = 10**data_nus * (1+z)
data_nus_rest_log = np.log10(data_nus_rest)
all_nus_rest = 10**all_nus
all_nus_obs = 10**all_nus / (1+z) #observed
distance= model.z2Dlum(z)
lumfactor = (4. * pi * distance**2.)
data_nuLnu_rest = data_flux* data_nus_obs *lumfactor
data_errors_rest=data_errors * data_nus_obs * lumfactor
fig, ax1, ax2, ax3, ax4 = SED_plotting_settings(all_nus_rest, data_nuLnu_rest)
plt.subplots_adjust(top=0.6, bottom=0, wspace=0)
#=================================
# INPUT AND BEST OUTPUT SED
#=================================
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, filtered_modelpoints_best, iSBnuLnu, iBBnuLnu, iGAnuLnu, iTOnuLnu, iTOTALnuLnu,iBBnuLnu_deredd, ifiltered_modelpoints_lum = PLOT_SED_bestfit(source, data_nus, data_flux, data_errors, z, all_nus, FLUXES4plotting, filtered_modelpoints, ifiltered_modelpoints)
SBcolor, BBcolor, GAcolor, TOcolor, TOTALcolor, grey= SED_colors(combination = 'a')
lw =2
ip1= ax1.plot( all_nus, iTOTALnuLnu, marker="None", linewidth=lw, linestyle='--', label="1 /sigma", color= TOTALcolor, alpha= 1.0)
ip2=ax1.plot(all_nus, iSBnuLnu, marker="None", linewidth=lw, linestyle='--',label="1 /sigma", color= SBcolor, alpha = 1)
ip3=ax1.plot(all_nus, iBBnuLnu, marker="None", linewidth=lw, linestyle='--',label="1 /sigma",color= BBcolor, alpha = 1)
ip4=ax1.plot( all_nus, iGAnuLnu,marker="None", linewidth=lw, linestyle='--',label="1 /sigma",color=GAcolor, alpha = 1)
ip5=ax1.plot( all_nus, iTOnuLnu, marker="None", linewidth=lw, linestyle='--',label="1 /sigma",color= TOcolor, alpha = 1)
interp_total= interp1d(all_nus, iTOTALnuLnu, bounds_error=False, fill_value=0.)
iTOTALnuLnu_at_datapoints = interp_total(data_nus)
#plot data points. These are read out from PLOR_SED_bestfit
#ip6 = ax1.plot(data_nus_rest_log, ifiltered_modelpoints_lum , marker='*', linestyle="None", markersize=5, color="red", alpha = 1)
p1= ax1.plot( all_nus, TOTALnuLnu, marker="None", linewidth=lw, label="1 /sigma", color= TOTALcolor, alpha= 1.0)
p2=ax1.plot(all_nus, SBnuLnu, marker="None", linewidth=lw, label="1 /sigma", color= SBcolor, alpha = 1)
p3=ax1.plot(all_nus, BBnuLnu, marker="None", linewidth=lw, label="1 /sigma",color= BBcolor, alpha = 1)
p4=ax1.plot( all_nus, GAnuLnu,marker="None", linewidth=lw, label="1 /sigma",color=GAcolor, alpha = 1)
p5=ax1.plot( all_nus, TOnuLnu, marker="None", linewidth=lw, label="1 /sigma",color= TOcolor, alpha = 1)
interp_total= interp1d(all_nus, TOTALnuLnu, bounds_error=False, fill_value=0.)
TOTALnuLnu_at_datapoints = interp_total(data_nus)
p6 = ax1.plot(data_nus_rest_log, filtered_modelpoints_best[0] , marker='o', linestyle="None", markersize=5, color="red", alpha = 1)
(_, caps, _) = ax1.errorbar(data_nus_rest_log, data_nuLnu_rest, yerr= data_errors_rest, capsize=4, linestyle="None", linewidth=lw, marker='o',markersize=5, color="black")
#=================================
# MANY REALIZATIONS SED
#=================================
SBnuLnu, BBnuLnu, GAnuLnu, TOnuLnu, TOTALnuLnu, BBnuLnu_deredd, filtered_modelpoints = PLOT_SED_manyrealizations(source, data_nus, data_flux, data_errors, z, all_nus, FLUXES4plotting, filtered_modelpoints, Nrealizations)
thinning_4plot = len(TOTALnuLnu) / (Nrealizations)
for j in range(Nrealizations):
i = j * 10
#Settings for model lines
q2=ax3.plot(all_nus, SBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= SBcolor, alpha = 0.4)
q3=ax3.plot(all_nus, BBnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= BBcolor, alpha = 0.4)
q4=ax3.plot( all_nus, GAnuLnu[i],marker="None", linewidth=lw, label="1 /sigma",color=GAcolor, alpha = 0.4)
q5=ax3.plot( all_nus, TOnuLnu[i], marker="None", linewidth=lw, label="1 /sigma",color= TOcolor ,alpha = 0.4)
q1= ax3.plot( all_nus, TOTALnuLnu[i], marker="None", linewidth=lw, label="1 /sigma", color= TOTALcolor, alpha= 0.4)
interp_total= interp1d(all_nus, TOTALnuLnu[i], bounds_error=False, fill_value=0.)
TOTALnuLnu_at_datapoints = interp_total(data_nus)
(_, caps, _) = ax3.errorbar(data_nus_rest_log, data_nuLnu_rest, yerr= data_errors_rest, capsize=4, linestyle="None", linewidth=1.5, marker='.',markersize=5, color="black", alpha = 0.4)
q6 = ax3.plot(data_nus_rest_log, filtered_modelpoints[i] , marker='o', linestyle="None",markersize=5, color="red")
ax1.annotate(r'\hspace{0.1cm} \\z ='+ str(z)+ r' \\ input = dashed lines \\ output maximum likelihood = solid line ' , xy=(0, 0.5), xycoords='axes points', xytext=(20, 380), textcoords='axes points', fontsize=16 )
ax3.annotate(r'output realizations from PDF' , xy=(0, 0.1), xycoords='axes points', xytext=(20, 380), textcoords='axes points', fontsize=16 )
print ' => SEDs of '+ str(Nrealizations)+' different realization were plotted.'
#=================================
# TABLE
#=================================
itau, iage, inh, iirlum, iSB ,iBB, iGA, iTO, iBBebv, iGAebv= mock_input[np.float(source)]
tau_e, age_e, nh_e, irlum_e, SB_e, BB_e, GA_e, TO_e, BBebv_e, GAebv_e, Mstar_e, SFR_e, SFR_file_e, Lfir_e, Lir_e, Lbol_e, Lbol_deredd_e = np.loadtxt('/data2/calistro/AGNfitter/OUTPUT/'+str(source)+'/parameters_with_errors_'+str(source)+'.txt', usecols=(0,1,2,3,4,5,6,7,8,9,10,11, 12, 13,14,15, 16), unpack=True , dtype = ('S'))
iage = '%.3s'%np.log10(np.float(iage))
sourceline2_0 = [tau_e[0], age_e[0], nh_e[0], irlum_e[0], SB_e[0], BB_e[0], GA_e[0], TO_e[0], BBebv_e[0], GAebv_e[0]]
sourceline2_1 = [tau_e[1], age_e[1], nh_e[1], irlum_e[1], SB_e[1], BB_e[1], GA_e[1], TO_e[1], BBebv_e[1], GAebv_e[1]]
sourceline2_2 = [tau_e[2], age_e[2], nh_e[2], irlum_e[2], SB_e[2], BB_e[2], GA_e[2], TO_e[2], BBebv_e[2], GAebv_e[2]]
outputline_0 = ['%.4s' %i for i in sourceline2_0]
outputline_1 = ['%.4s' %i for i in sourceline2_1]
outputline_2 = ['%.4s' %i for i in sourceline2_2]
outputline = [r'$%.4s ^{%.4s} _{%.4s} $' %(outputline_0[i], outputline_1[i], outputline_2[i]) for i in range(len(sourceline2_0))]
rows = [r'$\tau$', 'age', r'N$_h$', r'lum$_{IR}$', 'SB', 'BB', 'GA', 'TO', r'E(B-V)$_{bbb}$', r'E(B-V)$_{gal}$']
columns = [r'input', r'output']
tablearray = np.array([(itau, iage, inh, iirlum, iSB ,iBB, iGA,iTO, iBBebv, iGAebv), outputline ])
tablearray_transpose = tablearray.T
the_table = plt.table(cellText= tablearray_transpose,
colWidths=[1,1],
rowLabels=rows,
colLabels=columns, loc ='center', bbox=[-1.25, 0, 0.25, 1] ,cellLoc='center')
#Changing heights
table_props = the_table.properties()
table_cells = table_props['child_artists']
for cell in table_cells: cell.set_height(0.1)
the_table.set_fontsize(18)
# Adjust layout to make room for the table:
if catalog == 'data/MOCKagntype1.txt':
print '/data2/calistro/AGNfitter/OUTPUT/MOCKagn1/'+str(source)+'/bigplot.pdf'
plt.savefig('/data2/calistro/AGNfitter/OUTPUT/'+str(source)+'/bigplot_'+str(source)+'.pdf',bbox_inches='tight')
plt.close(fig)
if catalog == 'data/MOCKagn.txt':
print '/Users/Gabriela/Codes/AGNfitter/OUTPUT/MOCK/'+str(source)+'/bigplot.pdf'
plt.savefig('/data2/calistro/AGNfitter/OUTPUT/'+str(source)+'/bigplot_'+str(source)+'.pdf',bbox_inches='tight')
plt.close(fig)
elif catalog == 'data/MOCKagntype2.txt':
print '/data2/calistro/AGNfitter/OUTPUT/'+str(source)+'/bigplot.pdf'
plt.savefig('/data2/calistro/AGNfitter/OUTPUT/'+str(source)+'/bigplot_'+str(source)+'.pdf',bbox_inches='tight')
plt.close(fig)
def general_plot1(filename, catalog, sourceline, P, folder, opt, dict_modelsfiles, filterdict, path_AGNfitter, dict_modelfluxes):
data_nus, ydata, ysigma = DATA(catalog, sourceline)
z = REDSHIFT(catalog, sourceline)
sourcename = NAME(catalog, sourceline)
path = os.path.abspath(__file__).rsplit('/', 1)[0]
if not os.path.lexists(folder+str(sourcename)+'/samples_mcmc.sav'):
print 'Error: The MCMC sampling has not been perfomed yet, or the chains were not saved properly.'
#==============================================
samples = general.loadobj(filename)
#nwalkers, nsamples, npar = samples['chain'].shape
#ntemps, nwalkers, nsamples, npar = samples['chain'].shape
nwalkers, nsamples, npar = samples['chain'].shape
mean_accept = samples['accept'].mean()
print 'Mean acceptance fraction', mean_accept
#======================================
if filename.startswith(folder+str(sourcename)+'/samples_mcmc'):
#Thinning
Ns, Nt = opt['Nsample'], opt['Nthinning']
assert Ns * Nt <= nsamples
chain_flat = samples['chain'][:,0:Ns*Nt:Nt,:].reshape(-1, npar)
#mix all walkers' steps into one chain
#of shape [(nwalkers*steps), parameters]
lnprob = samples['lnprob'][:,0:Ns*Nt:Nt].ravel()
isort = (-lnprob).argsort() #sort parameter vector for likelihood
lnprob_sorted = np.reshape(lnprob[isort],(-1,1))
lnprob_max = lnprob_sorted[0]
chain_flat_sorted = chain_flat[isort]
best_fit_par = chain_flat[isort[0]]
total_length_chain = int(len(chain_flat))
Nthin_compute = opt['realizations2compute'] #thinning chain to compute small
#number of luminosities
Nrealizations = opt['realizations2plot'] #thinning it even more
#for doing fewer superposed plots
# calculate the model fluxes, mapping parameter space values to observables.
#=====================THE INPUT PARAMETERS=================================
if catalog == 'data/MOCKagntype1.txt':
mock_input, z_t1 = mock1.MOCKdata_chain()
if catalog == 'data/MOCKagn.txt':
mock_input, z_t1 = mock1.MOCKdata_chain()
elif catalog == 'data/MOCKagntype2.txt':
mock_input, z_t2 = mock2.MOCKdata_chain()
all_nus, FLUXES4plotting, filtered_modelpoints, ifiltered_modelpoints = fluxes_arrays(data_nus, catalog, sourceline, dict_modelsfiles, filterdict, chain_flat_sorted, Nthin_compute,path_AGNfitter, dict_modelfluxes, mock_input)
distance = model.z2Dlum(z)
chain_best_sigma =[]
for i in range(int(0.65*len(chain_flat_sorted))):
chain_best_sigma.append(chain_flat_sorted[i])
chain_best_sigma = np.array(chain_best_sigma)
#===================PLOT SEDS=======================
plot_nr1 = PLOT_nr1(sourcename, catalog, data_nus, ydata, ysigma, z, all_nus, FLUXES4plotting, filtered_modelpoints, ifiltered_modelpoints, Nrealizations, mock_input)
print '************ =) ***********'
