def calc_mags_z(zarray=arange(3.0, 6.1, 0.1), bands=['b', 'v', 'i', 'z']): # calculate the B-V v.s. V-z color-color track for the fiducial LBG template SED # use E(B-V) = 0.0, 0.15, and 0.3 as the value for dust extinction sp_ext0 = S.FileSpectrum('mylbg_sfr10.sed') ext15 = S.Extinction(0.15, 'xgal') ext30 = S.Extinction(0.30, 'xgal') sp_ext15 = sp_ext0 * ext15 sp_ext30 = sp_ext0 * ext30 mag_meik = {} mag_mad = {} mag_meik['zarray'] = zarray mag_mad['zarray'] = zarray for b in bands: mag_meik[b] = {} mag_mad[b] = {} for b in bands: mag_meik[b]['ext0'] = zeros(len(zarray)) mag_meik[b]['ext15'] = zeros(len(zarray)) mag_meik[b]['ext30'] = zeros(len(zarray)) mag_mad[b]['ext0'] = zeros(len(zarray)) mag_mad[b]['ext15'] = zeros(len(zarray)) mag_mad[b]['ext30'] = zeros(len(zarray)) for i in range(len(zarray)): for b in bands: mag_meik[b]['ext0'][i] = magredshift.mag_redshift( sp_ext0, zarray[i], bandpasses[b], igmroutine=igmtrans.meiksin)[0] mag_meik[b]['ext15'][i] = magredshift.mag_redshift( sp_ext15, zarray[i], bandpasses[b], igmroutine=igmtrans.meiksin)[0] mag_meik[b]['ext30'][i] = magredshift.mag_redshift( sp_ext30, zarray[i], bandpasses[b], igmroutine=igmtrans.meiksin)[0] mag_mad[b]['ext0'][i] = magredshift.mag_redshift( sp_ext0, zarray[i], bandpasses[b], igmroutine=igmtrans.madau)[0] mag_mad[b]['ext15'][i] = magredshift.mag_redshift( sp_ext15, zarray[i], bandpasses[b], igmroutine=igmtrans.madau)[0] mag_mad[b]['ext30'][i] = magredshift.mag_redshift( sp_ext30, zarray[i], bandpasses[b], igmroutine=igmtrans.madau)[0] return mag_meik, mag_mad
def make_mconvert_1500_z(zlo, zhi, dz, mcfile, ebmv=0.15, H0=70., omega_m=0.3, omega_l=0.7): calz = S.Extinction(ebmv, 'xgal') # dust obscuration sp_ext = sp10 * calz # dust obscured SED mconvertfile(sp_ext, zlo, zhi, dz, mcfile, restband=uni1500, obsband=zband, H0=H0, omega_m=omega_m, omega_l=omega_l) return 0
def __init__(self, template, refband=VJohnson, refmag=-21.0, ebmv=0., extlaw='xgal', filters=default_filters, cosmo=cosmo_def): self.template = template self.sp = S.FileSpectrum(template) if ebmv > 0: self.sp = self.sp * S.Extinction(ebmv, extlaw) if type(refband) == type(1500.): self.refband = S.Box(refband, 100.) else: self.refband = refband self.refmag = refmag self.filternames = [f.name for f in filters] self.kcorrs = {} for f in filters: self.kcorrs[f.name] = kcorr.KCorrect(self.sp, self.refband, f) if type(cosmo) == type([]): self.cosmo = cosmoclass.cosmoclass(H0=cosmo[0], omega_m=cosmo[1], omega_l=cosmo[2]) else: self.cosmo = cosmo
def __init__(self, ebvRange, wave, enableDIB=False, enableFlux=True, extinctionLaw='gal3'): self.points = np.array(ebvRange) values = [] for ebv in ebvRange: extinctFlux = np.ones(wave.shape) if enableFlux: extinct = pysynphot.Extinction(ebv, extinctionLaw) extinctThroughPut = extinct.GetThroughput()[::-1] f = interpolate.interp1d(extinct.wave[::-1], extinctThroughPut) extinctFlux *= f(wave) if enableDIB: extinctFlux *= pydib.makeSpectrum(wave, ebv).flux values.append(extinctFlux) self.values = np.array(values) self.interpGrid = interpolate.interp1d(self.points, self.values.transpose(), fill_value=1, bounds_error=False)
def __init__(self, ebvRange, wave, enableDIB=False, enableFlux=True, extinctionLaw='gal3', normRange=None): self.points = np.array(ebvRange) values = [] for ebv in ebvRange: extinctFlux = np.ones(wave.shape) if enableFlux: extinct = pysynphot.Extinction(ebv, extinctionLaw) extinctThroughPut = extinct.GetThroughput()[::-1] f = interpolate.interp1d(extinct.wave[::-1], extinctThroughPut) extinctFlux *= f(wave) if enableDIB: extinctFlux *= pydib.makeSpectrum(wave, ebv).flux if normRange != None: extinctFluxSpec = oned.onedspec(wave, extinctFlux, mode='waveflux') extinctFlux /= np.mean(extinctFluxSpec[slice(*normRange)].flux) values.append(extinctFlux) self.values = np.array(values) self.interpGrid = interpolate.interp1d(self.points, self.values.transpose(), fill_value=1, bounds_error=False, kind='cubic')
def calc_dict(reddenings): EBmV_dict = {} # { 0.0 : [u-g, g-r, r-i], ... } for EBmV in reddenings: spectrum = S.ArraySpectrum(np.array(wl), np.array(flx), 'angstrom', 'flam') spectrum = spectrum * S.Extinction(EBmV, 'mwavg') #calculate colours obs_u = S.Observation(spectrum, u_bp) obs_g = S.Observation(spectrum, g_bp) obs_r = S.Observation(spectrum, r_bp) obs_i = S.Observation(spectrum, i_bp) u_min_g = obs_u.effstim(magsystem) - obs_g.effstim(magsystem) g_min_r = obs_g.effstim(magsystem) - obs_r.effstim(magsystem) r_min_i = obs_r.effstim(magsystem) - obs_i.effstim(magsystem) #Add EBmV and colours to the dictionary colours = [u_min_g, g_min_r, r_min_i] EBmV_dict[EBmV] = colours return EBmV_dict
def __call__(self, z_range, obsband, outputfile): # Because m(z) = M + DM(z) + K_QR(z) := M + dm, # so dm = DM + K_QR. dm = np.zeros(len(z_range)) sp = S.FileSpectrum(self.sedfile) dust = S.Extinction(self.ebmv, self.extlaw) sp_ext = sp * dust K = kcorr.KCorrect(sp_ext, self.Q, obsband, mode='AB') for i in range(len(z_range)): z = z_range[i] ## Use my own (clumsy) way to compute dm # m = self.factory.redshift(z_range[i]).ABmag(obsband) # dm[i] = m - self.normmag # self.factory.reset() ## Use my implementation of Hogg et al. K-correction dm[i] = self.cosmo.distmod(z) + K(z) if i % 20 == 0: sys.stdout.write('z = %.3f \r' % z_range[i]) sys.stdout.flush() f = open(outputfile, 'wb') f.write('# 1 z \n') f.write('# 2 dm \n') for i in range(len(z_range)): f.write('%.4f %.6f \n' % (z_range[i], dm[i])) f.close() print "Done!"
def get_model_spectra(teff, mh, logg, model='ck04models', L=1, ebv=0): ''' For example: Temperature Teff=10000K, [M/H] = +0.1 and gravity log=3.0. model is the stellar model: Castelli-Kurucz - ck04models Kurucz 1993 Atlas - k93models Parameters ---------- teff : float The effective temperature of the star (in K). mh : string The metallicity as [M/H]. logg : float The log g of the stellar model. model : string Gride stellar models that can be used to retrieve the models for stellar spectra. See: https://pysynphot.readthedocs.io/en/latest/appendixa.html for a description. Castelli-Kurucz - ck04models Kurucz 1993 Atlas - k93models Phoenix (F. Allard et al.) - phoenix L : float The bolometric luminosity of the star (in Lsun). It will be used to normalize the spectrum. ebv : float, default: 0 The reddening to be applied to the model spectrum. Returns ------- s: pysynphot ArraySpectrum The spectrum corresponding to the stellar model, scaled to the luminosity. Examples -------- Temperature Teff=10000K, [M/H] = +0.1 and gravity log=3.0 for a star of 1 Lsun and no extinction. s = get_model_spectra(10000, 0.1, 3.0, model='ck04models', L=1, ebv=0) ''' sp = ps.Icat(model, teff, mh, logg) if ebv != 0: sp = sp * ps.Extinction(ebv, 'lmcavg') F_model = sp.trapezoidIntegration(sp.wave, sp.flux)*(u.erg/u.s/u.cm**2) #In erg / s / cm**2 Lmodel = (4 * np.pi * ((10*u.pc).to(u.cm))**2 * F_model ).to(u.Lsun) norm = L/Lmodel newflux = sp.flux * norm s = ps.ArraySpectrum(sp.wave, newflux, fluxunits="flam") return s
def fit_beta_sed(sedfile, beta0, ebmv=0.): # a wrapper that takes an SED, read it with pysynphot, and find the best-fit beta sp = S.FileSpectrum(sedfile) if ebmv > 0.: sp = sp * S.Extinction(ebmv, 'xgal') wave = sp.wave[(sp.wave >= 1220.) & (sp.wave <= 3200.)] # the rest-frame wavelength range sedflux = sp.sample(wave) # the flux from sp x = fit_beta(wave, sedflux, beta0=beta0) return x[0][0]
def test_merge_wave_sets(self): bb = S.BlackBody(20000) ext = S.Extinction(0.04, 'gal1') new_wave = S.spectrum.MergeWaveSets(bb.wave, ext.wave) delta = new_wave[1:] - new_wave[:-1] self.assertTrue((delta > S.spectrum.MERGETHRESH).all(), msg='Deltas should be < %g, min delta = %f' % (S.spectrum.MERGETHRESH, delta.min()))
def get_synthetic_mag_file(filename, filt_out, system_out, filt_in=None, mag_in=None, system_in=None, ebv=0, force=None): ''' Scales the input spectrum (read from the filename file) to the magnitude provided in the filter_in band, and obtains the synthetic photometry in the filter_out band. If no scaling magnitude is provided, the original spectrum is used to compute the synthetic mangitude. Parameters ---------- filename : string The name of the file which contains the spectrum. filt_out : string The name of the filter the system will compute the output of. system_out : string The system in which the output magntiudes are measured. "abmag" or "vegamag" or "stmag" filt_in : string The name of the filter we want to scale the spectrum. mag_in : float The mangtude of the object in the filter_in band. system_in : string The system in which the input magntiude is measured. "abmag" or "vegamag" or "stmag" ebv : float, default: 0 The reddening to be applied to the model spectrum. force : string, default: None Whether the magnitude should be extrapolated in case the filter and the spectrum wavelengths do not completely overlap. You may use force=[extrap|taper] to force this Observation anyway. Returns ------- mag_out : float The synthetic photometry magnitude of the input spectrum once scaled to its mag_in value in filter_out band. ''' sp = ps.FileSpectrum(filename) sp_ext = sp * ps.Extinction(ebv, 'mwavg') if not( filt_in is None or mag_in is None or system_in is None): sp_norm = sp_ext.renorm(mag_in, system_in, ps.ObsBandpass(filt_in)) else: sp_norm = sp_ext try: obs = ps.Observation(sp_norm, ps.ObsBandpass(filt_out), binset=sp_norm.wave, force=force) except ValueError: bp = ps.FileBandpass(banddic[filt_out]) obs = ps.Observation(sp_norm, bp, binset=sp.wave) mag_out = obs.effstim(system_out) return mag_out
def get_grid_phoenixmodels_extinct(extvalue): index = 1 for temp in Temperature_range: for logg in Set_Log_G: for logz in Set_Log_Z: data[index, index_temp] = temp data[index, index_logg] = logg data[index, index_logz] = logz sed = S.Icat('phoenix', temp, logz, logg) * S.Extinction( extvalue, 'mwavg') sed.convert( 'flam') # to be sure every spectrum is in flam unit if (max(sed.flux) > 0): # remove empty fluxes because of bad parameters data[index, index_val] = 1 func = interp1d(sed.wave, sed.flux, kind='cubic') flux = func(WL) data[index, index_spec:] = flux index += 1
def create_stellar_atmosphere_grid(BPs = ['acs,wfc1,f475w'], ZPs = [26.168e0], ebv = 0.01, Z = 0.01): import pysynphot as S BPs = [S.ObsBandpass(BP) for BP in BPs] spectra = glob.glob('./data/grp/hst/cdbs/grid/ck04models/ckm{Z}/ckm{Z}*.fits'.format(Z = int(Z*1000))) logg_range = np.arange(0,5.5,0.5) filter_mag_grids = {} for BP in range(len(BPs)): magnitudes = np.zeros([len(logg_range)*len(spectra),3]) for ii in range(len(spectra)): spec_file = spectra[ii] Teff = file.split('_')[1].split('.')[0] for logg in logg_range: gg = 'g{0:02d}'.format(10*logg) base_spec = S.FileSpectrum(spec_file,fluxname = gg) base_spec = base_spec * (6.957e8 / 3.0857e19)**2.e0 if sum(base_spec.flux) != 0: spec = base_spec * S.Extinction(ebv,'gal3') obs = S.Observation(spec,BPs[BP]) count = obs_475.countrate() mag = -2.5e0 * np.log10(count) + ZPs[BP] else: mag = np.nan magnitudes[0] = logg magnitdues[1] = Teff magnitudes[2] = mag print('done {}'.format(gg)) print('done {}'.format(Teff)) filter_mag_grids[BPs[BP]] = magnitues f = open('model_atmosphere_ebv{ebv:.3f}_Z{Z:.3f}.dat'.format(ebf=ebv,Z=Z),'w') f.write(str(filter_mags)) f.close()
def test4(self): self.xt = S.Extinction(0.2, S.Cache.RedLaws['smcbar']) self.assertTrue(isinstance(self.xt, spectrum.SpectralElement))
def calc_reddened_colours(temp): magsystem = 'vegamag' #read in transmission tables describing the VPHAS+ filter curves fpaths = glob.glob( '/mirror2/scratch/hbarker/Macquarie/CS_synthetic_colours/vphas_atmosphere_included_filters/*.dat' ) for fpath in fpaths: bandpass = S.FileBandpass(fpath) with open(fpath, 'r') as f: tab = [line.strip().split() for line in f] #if 'u_SDSS' in fpath: # u_bp = bandpass #elif 'g_SDSS' in fpath: # g_bp = bandpass #use the filtercurved emailed by Janet Drew that contain the known u # and g band red leak if 'u-transmission' in fpath: bandpass = S.FileBandpass(fpath) u_bp = bandpass elif 'g-transmission' in fpath: bandpass = S.FileBandpass(fpath) g_bp = bandpass elif 'r_SDSS' in fpath: r_bp = bandpass elif 'i_SDSS' in fpath: i_bp = bandpass #read in PN model spectra from the TMAP models tmap_paths = glob.glob( '/mirror2/scratch/hbarker/Macquarie/CS_synthetic_colours/TubingenModels/' + str(temp) + 'kK_7.0_solar/*.txt') if len(tmap_paths) == 0: print 'File does not exist' print '/mirror2/scratch/hbarker/Macquarie/CS_synthetic_colours/TubingenModels/' + str( temp) + 'kK_7.0_solar/*.txt' sys.exit() fpath = tmap_paths[0] #read the spectrum into a table colnames = ['lambda', 'F_lambda'] wl = [] flx = [] with open(fpath, 'r') as f: for line in f: line = line.split() wl.append(float(line[0])) #A #convert flux from erg/cm**2/s/cm to erg/s/cm**2/A flx_cgs = float(line[1]) * 1e-8 flx.append(flx_cgs) #E(B-V) values to calculate reddenings = np.arange(0, 31, 1) #0, 0.1, 0.2, ...., 2.9, 3.0 reddenings = [round(line / 10., 3) for line in reddenings] EBmV_dict = {} # { 0.0 : [u-g, g-r, r-i], ... } for EBmV in reddenings: #construct spectrum for pysynphot spectrum = S.ArraySpectrum(np.array(wl), np.array(flx), 'angstrom', 'flam') #convert from flam to photons, as colours need to be calculatated in photon counts spectrum.convert('counts') #redden the spectrum using cardelli1989 and Rv=3.1 spectrum = spectrum * S.Extinction(EBmV, 'mwavg') obs_u = S.Observation(spectrum, u_bp) obs_g = S.Observation(spectrum, g_bp) obs_r = S.Observation(spectrum, r_bp) obs_i = S.Observation(spectrum, i_bp) #calculate colours u_min_g = obs_u.effstim(magsystem) - obs_g.effstim(magsystem) g_min_r = obs_g.effstim(magsystem) - obs_r.effstim(magsystem) r_min_i = obs_r.effstim(magsystem) - obs_i.effstim(magsystem) #Add EBmV and colours to the dictionary colours = [u_min_g, g_min_r, r_min_i] EBmV_dict[EBmV] = colours return EBmV_dict
('pickles_uk_40', 'M2V'), ('pickles_uk_43', 'M4V'), ('pickles_uk_44', 'M5V')) # Lightpath data instrument = 'ucam' telescope = 'ntt' filt = 'super' # Apply extinction to that spectrum a_g = 0.561 # a_g = 0.0 # Convert from Gaia Ag to EBV a_v = a_g / 0.789 ebv = a_v / 3.1 ext = S.Extinction(ebv, 'gal3') # SDSS filters sdss_filters = ['u', 'g', 'r', 'i', 'z'] # Super SDSS filters super_filters = ['u_s', 'g_s', 'r_s', 'i_s', 'z_s'] cam_filters = super_filters if filt == 'super' else sdss_filters # Lets store it all in a pandas dataframe. INFO = ['SpecType', 'PicklesName'] SDSS_COLOURS = ['u-g', 'g-r', 'r-i', 'i-z'] CORRECTIONS = ["{}-{}".format(a, b) for a, b in zip(cam_filters, sdss_filters)] COLNAMES = INFO + SDSS_COLOURS + CORRECTIONS table = pd.DataFrame(columns=COLNAMES)
#expected flux per cm^2 at 1kpc F = L / (4 * math.pi * (distance**2)) #erg/s/cm^2 /ster? #Expected flux per sq cm of a CS at the distance print 'Flux at ', distance_parsec, 'pc: ', F, 'erg/s/cm^2' #calcualte multiplication factor needed to convert the input spectum to one of an object at 1kpc m_factor = F / total_flux new_flux = [line['F_lambda'] * m_factor for line in spectrum] #erg/s/cm^2 #multiply by the star's surface area to get erg/s new_flux = [line * SA for line in new_flux] #redden the array using CCM1998, Rv=3.1 spectrum = S.ArraySpectrum(np.array(wl), np.array(new_flux), 'angstrom', 'flam') spectrum = spectrum * S.Extinction(EBmV, 'mwavg') #calculate colours obs_u = S.Observation(spectrum, u_bp) obs_g = S.Observation(spectrum, g_bp) obs_r = S.Observation(spectrum, r_bp) obs_i = S.Observation(spectrum, i_bp) u_mag = obs_u.effstim(magsystem) g_mag = obs_g.effstim(magsystem) r_mag = obs_r.effstim(magsystem) i_mag = obs_i.effstim(magsystem) u_min_g = obs_u.effstim(magsystem) - obs_g.effstim(magsystem) g_min_r = obs_g.effstim(magsystem) - obs_r.effstim(magsystem) r_min_i = obs_r.effstim(magsystem) - obs_i.effstim(magsystem)
#flux of whole star at Earth = BB_flux* 4*pi*/D^2 #D=1kpc=3.086e16m = 3.086e18cm distance_parsec = distance #pc distance_m = distance_parsec * 3.086e16 #meters distance_cm = distance_m * 100 #cm F = expected_lum / (4*math.pi*(distance_cm**2)) #expected flux of the star at the distance factor = F / total_flux spect = [val * factor for val in spect] #convolve with the vphas bands spectrum=S.ArraySpectrum(np.array(wavelengths_AA), np.array(spect), waveunits='angstrom', fluxunits='flam') #redden the spectrum spectrum = spectrum * S.Extinction(reddening, 'mwavg') #calculate magnitudes and colours using pysynphot obs_u = S.Observation(spectrum, u_bp) obs_g = S.Observation(spectrum, g_bp) obs_r = S.Observation(spectrum, r_bp) obs_i = S.Observation(spectrum, i_bp) u = obs_u.effstim(magsystem) g = obs_g.effstim(magsystem) r = obs_r.effstim(magsystem) i = obs_i.effstim(magsystem) parameters.append(u) parameters.append(g)
cs_factor = F_CS/CS_total_flux CS = [val*cs_factor for val in CS] #sum the flux of the CS and MS stars spectra_sum = [line[0]+line[1] for line in zip(CS, MS)] #convolve with the vphas bands spectrum=S.ArraySpectrum(np.array(wavelengths_AA), np.array(spectra_sum), waveunits='angstrom', fluxunits='flam') """apply a reddening to the binary's spectrum""" spectrum = spectrum * S.Extinction(EBmV_applied, 'mwavg') #calculate magnitudes and colours using pysynphot obs_u = S.Observation(spectrum, u_bp) obs_g = S.Observation(spectrum, g_bp) obs_r = S.Observation(spectrum, r_bp) obs_i = S.Observation(spectrum, i_bp) obs_V = S.Observation(spectrum, S.ObsBandpass('V')) obs_B = S.Observation(spectrum, S.ObsBandpass('B')) obs_R = S.Observation(spectrum, S.ObsBandpass('R')) obs_J = S.Observation(spectrum, S.ObsBandpass('J')) u = obs_u.effstim(magsystem) g = obs_g.effstim(magsystem)
flx.append(float(line[1]) * 1e-8) #convert to per angstrom spectrum = S.ArraySpectrum(np.array(wl), np.array(flx), 'angstrom', 'flam') #convert from flam to photons, as colours need to be calculatated in photon counts spectrum.convert('counts') #redden the spectrum using Cardelli 1989, RV=3.1 E_BmV = [ 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9 ] for e in E_BmV: red_spectrum = spectrum * S.Extinction(e, 'mwavg') #calcuate colours obs_u = S.Observation(red_spectrum, u_bp) obs_g = S.Observation(red_spectrum, g_bp) obs_r = S.Observation(red_spectrum, r_bp) obs_i = S.Observation(red_spectrum, i_bp) obs_J = S.Observation(red_spectrum, J_bp) magsystem = 'vegamag' u_min_g = obs_u.effstim(magsystem) - obs_g.effstim(magsystem) g_min_r = obs_g.effstim(magsystem) - obs_r.effstim(magsystem) r_min_i = obs_r.effstim(magsystem) - obs_i.effstim(magsystem) #g_min_i = obs_g.effstim(magsystem) - obs_i.effstim(magsystem) #g_min_J = obs_g.effstim(magsystem) - obs_J.effstim(magsystem)
distance = distance * 100 #cm F = L / (4 * math.pi * (distance**2)) #erg/s/cm^2 print 'Flux at 10kpc: ', F, 'erg/s/cm^2' #calcualte multiplication factor needed to convert the input spectum to one of an object at 10kpc m_factor = F / total_flux new_flux = [line['F_lambda'] * m_factor for line in spectrum] #make recarray with new flux values #spectrum = make_recarray( zip(wl,new_flux), colnames) #redden the array using CCM1998 EBmV = 1.0 reddened_spectrum = S.ArraySpectrum(np.array(wl), np.array(new_flux), 'angstrom', 'flam') reddened_spectrum = reddened_spectrum * S.Extinction(EBmV, 'mwavg') spectrum = make_recarray( zip(reddened_spectrum.wave, reddened_spectrum.flux), colnames) wl = list(reddened_spectrum.wave) spectrum = S.ArraySpectrum(np.array(wl), np.array(reddened_spectrum.flux), 'angstrom', 'flam') """ #interpolate the u filter so the spectrum can be convolved with it filter_interp = interp1d(u['wavelength'], u['transmission'], kind='linear') filter_new = [] # u filter with same wavelength spacing as the spectrum convolved = [] for line in spectrum: if line['lambda']>min(u['wavelength']) and line['lambda']<max(u['wavelength']): flux_transmission = filter_interp(line['lambda']) convolved.append(flux_transmission * line['F_lambda'])
def setUp(self): #Uses new extinction functionality self.oldsmc = S.Extinction(0.2, 'smc') self.newsmc = S.Extinction(0.2, 'smcbar')
def mkinput(ngal, Mlo, Mhi, Mdist, extpar, zlo, zhi, bands, igmroutine=meiksin.meiksin, spec=SED_LBG2, extdist='uniform', lyadist='Lya_EW_dist.txt', w0=0., w1=20., restwave=1500.): """ Generate input catalog for LBG simulation Use randomly drawn values of E(B-V), z, absolute magnitude at the specified rest-frame wavelength, and Ly-alpha equivalent width. """ sp = S.FileSpectrum(spec) random.seed() # randomly draw E(B-V), z, and M # use either a flat distribution ('uniform') or a Gaussian distribution ('gaussian') if extdist == 'uniform': ebmvr = draw_ebmv_uniform(extpar[0], extpar[1], size=ngal) elif extdist == 'gaussian': ebmvr = draw_ebmv_gaussian(extpar[0], extpar[1], size=ngal) elif extdist == 'lognormal': ebmvr = draw_ebmv_lognormal(extpar[0], extpar[1], size=ngal) zr = draw_z_uniform( zlo, zhi, size=ngal ) # draw a redshift from a flat distribution between zlo and zhi if Mdist == 'uniform': Mr = draw_M_uniform(Mlo, Mhi, size=ngal) # draw an M_1500 from a flat distribution between Mlo and Mhi elif Mdist == 'single': # Use a single value for input absolute magnitude M=-21.0, therefore # will ignore MLO and MHI. # This is useful if one is interested in colors only; apparent magnitudes # can be scaled later with respect to the reference absolute magnitude Mr = ones(ngal) * -21.0 assert len(Mr) == ngal, "Input absolute magnitudes are not generated." #?? Should I draw from a reasonbly assumed LF?? # draw equivalent width from Lya EW distribution at z~1-3 provided by Naveen Reddy if lyadist == 'uniform': lya_ew = random.uniform(w0, w1, size=ngal) elif len(lyadist) > 0: ld = sextractor(lyadist) lya_ew = draw_lya(ngal, ld.lya_ew, ld.pdf) else: lya_ew = zeros(ngal) if bands == 'highz_bands': bands = {} for b in highz_bands: bands[b] = filters[b] else: bandnames = copy.copy(bands) bands = {} for b in bandnames: bands[b] = filters[b] mags = zeros((len(bands), ngal)) kc = zeros((len(bands), ngal)) restband = S.Box(restwave, 100.) for i in range(ngal): if i % 500 == 0: print "%d done." % i sys.stdout.flush() ext = S.Extinction(ebmvr[i], 'xgal') spec_ext = sp * ext # apply dust extinction to rest-frame SED # calculate observed magnitudes (normalized to M_1500 = Mr[i]) of each band, using the drawn redshift & # Lya EW for j in range(len(bands)): # b = bands[j] b = bands.keys()[j] mags[j][i], kc[j][i] = simkcorr.simkcorr(spec_ext, Mr[i], restband, bands[b], zr[i], lya_ew[i]) results = [] for i in range(len(bands)): results += [mags[i]] results += [zr, ebmvr, Mr, lya_ew] return array(results)
def test1(self): self.xt = S.Extinction(0.3, 'mwdense') self.assertTrue(isinstance(self.xt, spectrum.SpectralElement))
def test1(self): self.sp = S.Extinction(0.2, 'gal1') #Make an extinction law self.sp.convert('1/um') #convert to inverse microns refwave = extinction._buildDefaultWaveset() testwave = self.sp.wave self.assertApproxNumpy(testwave, refwave)
def make_mconvert_1500_z(zlo, zhi, dz, mcfile, ebmv=0.15): calz = S.Extinction(ebmv, 'xgal') # dust obscuration sp_ext = sp10 * calz # dust obscured SED mconvertfile(sp_ext, zlo, zhi, dz, mcfile, restband=uni1500, obsband=zband) return 0
def test6(self): self.xt = S.Extinction(0.3) self.assertTrue(isinstance(self.xt, spectrum.SpectralElement)) self.assertTrue('mwavg' in self.xt.name.lower())