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 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 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 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 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 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 '************ =) ***********'
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_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 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 '************ =) ***********'
