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