def load_models(self): """Load the BaSeL basis models, initialize the grid to hold resampled models, and load the filters""" self.basel = starmodel.BaSeL3() # BaSeL 3.1 Basis self.basel.read_all_Z() self.stargrid = starmodel.SpecLibrary() #object to hold the model grid self.model_filterlist = observate.load_filters(self.rp['model_fnamelist']) #filter objects self.fit_filterlist = observate.load_filters(self.rp['fit_fnamelist'])
def load_obs(**extras): """the key word will be "uvj_key" generate UVJ fluxes based off of this """ # first load the filters fnames = ['bessell_U','bessell_V','twomass_J'] # generate uvj color uv, vj = return_uvj(int(extras['uvj_key'])) # translate to fluxes # do this by fixing V-flux in maggies # this corresponds roughly to M~1e10 vflux = 5e7 maggies = np.array([10**(-uv/2.5), 1, 10**(vj/2.5)]) * vflux maggies_unc = maggies / 40. ### build output dictionary obs = {} obs['filters'] = observate.load_filters(fnames) obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = np.ones_like(maggies,dtype=bool) obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False obs['uv'] = uv obs['vj'] = vj return obs
def test_madau(): filternames = ["decam_u", "decam_g"] filterdir = "data/filters" filter_list = observate.load_filters(filternames, directory=filterdir) lambda_aa, f_lambda_aa = load_test_sed() speedoflight = 3e18 f_nu_aa = f_lambda_aa * lambda_aa**2 / speedoflight redshift_grid = np.linspace(0.0, 4, 4)[1:] redshifted_fluxes1, redshifted_fluxesb1, redshift_factor = get_redshifted_photometry( lambda_aa, f_lambda_aa, redshift_grid, filter_list, apply_madau_igm=False) redshifted_fluxes2, redshifted_fluxesb2, redshift_factor = get_redshifted_photometry( lambda_aa, f_lambda_aa, redshift_grid, filter_list, apply_madau_igm=True) assert np.any(redshifted_fluxes1 != redshifted_fluxes2) assert np.any(redshifted_fluxesb1 != redshifted_fluxesb2)
def test(): from sedpy import observate import fsps import matplotlib.pyplot as pl filters = [ 'galex_NUV', 'sdss_u0', 'sdss_r0', 'sdss_r0', 'sdss_i0', 'sdss_z0', 'bessell_U', 'bessell_B', 'bessell_V', 'bessell_R', 'bessell_I', 'twomass_J', 'twomass_H' ] flist = observate.load_filters(filters) sps = fsps.StellarPopulation(compute_vega_mags=False) wave, spec = sps.get_spectrum(tage=1.0, zmet=2, peraa=True) sed = observate.getSED(wave, spec, flist) sed_unc = np.abs(np.random.normal(1, 0.3, len(sed))) wgrid = np.linspace(2e3, 13e3, 1000) fgrid = np.linspace(-13, -9, 100) psed, sedpoints = sed_to_psed(flist, sed, sed_unc, wgrid, fgrid) pl.imshow(np.exp(psed).T, cmap='Greys_r', interpolation='nearest', origin='upper', aspect='auto')
def selftest(): from sedpy.observate import load_filters sps = sps_basis.StellarPopBasis(debug=True) params = {} params['tage'] = np.array([1, 2, 3, 4.]) params['zmet'] = np.array([-0.5, 0.0]) ntot = len(params['tage']) * len(params['zmet']) params['mass'] = np.random.uniform(0, 1, ntot) params['sigma_smooth'] = 100. outwave = sps.ssp.wavelengths flist = ['sdss_u0', 'sdss_r0'] filters = load_filters(flist) # get a spectrum s, p, e = sps.get_spectrum(params, outwave, filters) # change parameters that affect neither the basis nor the ssp, and # get spectrum again params['mass'] = np.random.uniform(0, 1, ntot) s, p, e = sps.get_spectrum(params, outwave, filters) # lets get the basis components while we're at it bs, bp, be = sps.get_components(params, outwave, filters) # change something that affects the basis params['tage'] += 1.0 bs, bp, be = sps.get_components(params, outwave, filters) # try a single age pop at arbitrary metallicity params['tage'] = 1.0 params['zmet'] = -0.2 bs, bp, be = sps.get_components(params, outwave, filters)
def load_obs(objname=None, noisefactor=1.0, calibrated=False, mask=True, broaden_obs=False, wlo=3750., whi=7500., **extras): assert objname == 'M67' bmag = 7.5 #hack obs = {} dat = np.loadtxt(os.path.join(sdir, 'data/m67_nobs.dat')) obs['wavelength'] = observate.vac2air(dat[:, 0]) obs['spectrum'] = dat[:, 1] obs['unc'] = dat[:, 2] obs['filters'] = observate.load_filters(['sdss_g0']) obs['maggies'] = np.array([10**(-0.4 * bmag)]) obs['maggies_unc'] = 0.05 * obs['maggies'] # mask obs['mask'] = (obs['wavelength'] > wlo) & (obs['wavelength'] < whi) #adjust uncertainties obs['unc'] *= noisefactor obs['noisefactor'] = noisefactor obs['spec_calibrated'] = calibrated return obs
def load_obs(photname='', objname='', **extras): """ Custom-built because the photometric files are actually generated by the model """ obs ={} # if the photometric files exist with open(photname, 'r') as f: hdr = f.readline().split() dat = np.loadtxt(photname, comments = '#', dtype = np.dtype([(n, np.float) for n in hdr[1:]])) obj_ind = np.where(dat['id'] == int(objname))[0][0] # extract fluxes+uncertainties for all objects and all filters flux_fields = [f for f in dat.dtype.names if f[0:2] == 'f_'] unc_fields = [f for f in dat.dtype.names if f[0:2] == 'e_'] filters = [f[2:] for f in flux_fields] # extract fluxes for particular object, converting from record array to numpy array flux = dat[flux_fields].view(float).reshape(len(dat),-1)[obj_ind] unc = dat[unc_fields].view(float).reshape(len(dat),-1)[obj_ind] # build output dictionary obs['filters'] = observate.load_filters(filters) obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = np.ones_like(flux,dtype=bool) obs['maggies'] = flux obs['maggies_unc'] = unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def load_data(self): """Read the catalogs, apply distance modulus, and determine 'good' pixels""" self.data_filterlist = observate.load_filters(self.rp['data_fnamelist']) self.data_mag, self.data_magerr, self.data_header = catio.load_image_cube(self.rp) self.distance_modulus = 5.0*np.log10(self.rp['dist'])+25 self.nobj = self.data_mag.shape[0]
def load_obs(objid=0, phottable='demo_photometry.dat', **kwargs): """Load photometry from an ascii file. Assumes the following columns: `objid`, `filterset`, [`mag0`,....,`magN`] where N >= 11. The User should modify this function (including adding keyword arguments) to read in their particular data format and put it in the required dictionary. :param objid: The object id for the row of the photomotery file to use. Integer. Requires that there be an `objid` column in the ascii file. :param phottable: Name (and path) of the ascii file containing the photometry. :returns obs: Dictionary of observational data. """ # Writes your code here to read data. Can use FITS, h5py, astropy.table, # sqlite, whatever. # e.g.: # import astropy.io.fits as pyfits # catalog = pyfits.getdata(phottable) # Here we will read in an ascii catalog of magnitudes as a numpy structured # array with open(phottable, 'r') as f: # drop the comment hash header = f.readline().split()[1:] catalog = np.genfromtxt(phottable, comments='#', dtype=np.dtype([(n, np.float) for n in header])) # Find the right row ind = catalog['objid'] == float(objid) # Here we are dynamically choosing which filters to use based on the object # and a flag in the catalog. Feel free to make this logic more (or less) # complicated. filternames = filtersets[ int(catalog[ind]['filterset']) ] # And here we loop over the magnitude columns mags = [catalog[ind]['mag{}'.format(i)] for i in range(len(filternames))] mags = np.array(mags) # Build output dictionary. obs = {} # This is a list of sedpy filter objects. See the # sedpy.observate.load_filters command for more details on its syntax. obs['filters'] = load_filters(filternames) # This is a list of maggies, converted from mags. It should have the same # order as `filters` above. obs['maggies'] = np.squeeze(10**(-mags/2.5)) # HACK. You should use real flux uncertainties obs['maggies_unc'] = obs['maggies'] * 0.07 # Here we mask out any NaNs or infs obs['phot_mask'] = np.isfinite(np.squeeze(mags)) # We have no spectrum. obs['wavelength'] = None # Add unessential bonus info. This will be stored in output #obs['dmod'] = catalog[ind]['dmod'] obs['objid'] = objid return obs
def load_obs(phot_file=run_params['phot_file'], **kwargs): import pandas as pd data = pd.read_csv(phot_file) flux = data[1:] maggies = flux / 1000. / 3631. unc = maggies * 0.1 flux_mag = np.asarray(maggies) unc_mag = np.asarray(unc) # Build output dictionary. obs = {} # This is a list of sedpy filter objects. See the # sedpy.observate.load_filters command for more details on its syntax. obs['filters'] = load_filters(filternames) # This is a list of maggies, converted from mJy. It should have the same # order as `filters` above. obs['maggies'] = flux_mag #Uncertainties also converted from mJy. In same order as flux_mag and filters obs['maggies_unc'] = unc_mag # Here we mask out any NaNs or infs obs['phot_mask'] = np.isfinite(flux_mag) # We have no spectrum. obs['wavelength'] = None return obs
def selftest(): from sedpy.observate import load_filters sps = sps_basis.StellarPopBasis(debug=True) params = {} params['tage'] = np.array([1, 2, 3, 4.]) params['zmet'] = np.array([-0.5, 0.0]) ntot = len(params['tage']) * len(params['zmet']) params['mass'] = np.random.uniform(0, 1, ntot) params['sigma_smooth'] = 100. outwave = sps.ssp.wavelengths flist = ['sdss_u0', 'sdss_r0'] filters = load_filters(flist) # get a spectrum s, p, e = sps.get_spectrum(params, outwave, filters) # change parameters that affect neither the basis nor the ssp, and # get spectrum again params['mass'] = np.random.uniform(0, 1, ntot) s, p, e = sps.get_spectrum(params, outwave, filters) # lets get the basis components while we're at it bs, bp, be = sps.get_components(params, outwave, filters) # change something that affects the basis params['tage'] += 1.0 bs, bp, be = sps.get_components(params, outwave, filters) # try a single age pop at arbitrary metallicity params['tage'] = 1.0 params['zmet'] = -0.2 bs, bp, be = sps.get_components(params, outwave, filters)
def load_obs(objid=0, phottable='demo_photometry.dat', **kwargs): """Load photometry from an ascii file. Assumes the following columns: `objid`, `filterset`, [`mag0`,....,`magN`] where N >= 11. The User should modify this function (including adding keyword arguments) to read in their particular data format and put it in the required dictionary. :param objid: The object id for the row of the photomotery file to use. Integer. Requires that there be an `objid` column in the ascii file. :param phottable: Name (and path) of the ascii file containing the photometry. :returns obs: Dictionary of observational data. """ # Writes your code here to read data. Can use FITS, h5py, astropy.table, # sqlite, whatever. # e.g.: # import astropy.io.fits as pyfits # catalog = pyfits.getdata(phottable) # Here we will read in an ascii catalog of magnitudes as a numpy structured # array with open(phottable, 'r') as f: # drop the comment hash header = f.readline().split()[1:] catalog = np.genfromtxt(phottable, comments='#', dtype=np.dtype([(n, np.float) for n in header])) # Find the right row ind = catalog['objid'] == float(objid) # Here we are dynamically choosing which filters to use based on the object # and a flag in the catalog. Feel free to make this logic more (or less) # complicated. filternames = filtersets[ int(catalog[ind]['filterset']) ] # And here we loop over the magnitude columns mags = [catalog[ind]['mag{}'.format(i)] for i in range(len(filternames))] mags = np.array(mags) # Build output dictionary. obs = {} # This is a list of sedpy filter objects. See the # sedpy.observate.load_filters command for more details on its syntax. obs['filters'] = load_filters(filternames) # This is a list of maggies, converted from mags. It should have the same # order as `filters` above. obs['maggies'] = np.squeeze(10**(-mags/2.5)) # Hack. you should use real flux uncertainties obs['maggies_unc'] = obs['maggies'] * 0.07 # Here we mask out any NaNs or infs obs['phot_mask'] = np.isfinite(np.squeeze(mags)) # We have no spectrum. obs['wavelength'] = None # Add unessential bonus info. This will be sored in output #obs['dmod'] = catalog[ind]['dmod'] obs['objid'] = objid return obs
def load_obs(objname, filterset=["sdss_g0", "sdss_r0"], **kwargs): obs = {} # Convert a model spectrum into broadband fluxes. from sedpy.observate import load_filters import pandas as pd c15 = pd.read_csv('C15_clean.csv') obj = c15.loc[c15['NUMBER'] == objname] obs['filters'] = load_filters(filterset) obs["phot_wave"] = [f.wave_effective for f in obs["filters"]] maggies = [] maggies_unc = [] for fil in filterset: maggies.append(float(obj[fil]) / 3.631e9) maggies_unc.append(float(obj[fil + '_err']) / 3.631e9) obs['maggies'] = np.array(maggies) obs['maggies_unc'] = np.array(maggies_unc) obs['phot_mask'] = np.ones(len(filterset), dtype=bool) # No spectrum obs['wavelength'] = None obs["spectrum"] = None return obs
def read_hdf5(filename, **extras): """Read an HDF5 file (with a specific format) into a dictionary of results. This HDF5 file is assumed to have the groups ``sampling`` and ``obs`` which respectively contain the sampling chain and the observational data used in the inference. All attributes of these groups as well as top-level attributes are loaded into the top-level of the dictionary using ``json.loads``, and therefore must have been written with ``json.dumps``. This should probably use JSONDecoders, but who has time to learn that. :param filename: Name of the HDF5 file. """ groups = {'sampling': {}, 'obs': {}} res = {} with h5py.File(filename, "r") as hf: # loop over the groups for group, d in groups.items(): # read the arrays in that group into the dictionary for that group for k, v in hf[group].items(): d[k] = np.array(v) # unserialize the attributes and put them in the dictionary for k, v in hf[group].attrs.items(): try: d[k] = json.loads(v) except: try: d[k] = unpick(v) except: d[k] = v # do top-level attributes. for k, v in hf.attrs.items(): try: res[k] = json.loads(v) except: try: res[k] = unpick(v) except: res[k] = v res.update(groups['sampling']) res['obs'] = groups['obs'] try: res['obs']['filters'] = load_filters( [str(f) for f in res['obs']['filters']]) except: pass try: res['rstate'] = unpick(res['rstate']) except: pass try: mp = [names_to_functions(p.copy()) for p in res['model_params']] res['model_params'] = mp except: pass return res
def load_obs(snr=10.0, add_noise=True, filterset=["sdss_g0", "sdss_r0"], **kwargs): """Make a mock dataset. Feel free to add more complicated kwargs, and put other things in the run_params dictionary to control how the mock is generated. :param snr: The S/N of the phock photometry. This can also be a vector of same lngth as the number of filters. :param add_noise: (optional, boolean, default: True) If True, add a realization of the noise to the mock spectrum :param filterset: A list of `sedpy` filter names. Mock photometry will be generated for these filters. """ mock = {} mock['wavelength'] = None # No spectrum # Convert a model spectrum into broadband fluxes. from sedpy.observate import load_filters mock['filters'] = load_filters(filterset) mock["phot_wave"] = [f.wave_effective for f in mock["filters"]] # We need the models to make a mock sps = load_sps(**kwargs) model = load_model(**kwargs) params = {} for p in model.params.keys(): if p in kwargs: params[p] = np.atleast_1d(kwargs[p]) # And build the mock SED model.params.update(params) spec, phot, mfrac = model.mean_model(model.theta, mock, sps=sps) # Now store some output mock['true_spectrum'] = spec.copy() mock['true_maggies'] = phot.copy() from copy import deepcopy mock['mock_params'] = deepcopy(model.params) # And add noise pnoise_sigma = phot / snr if add_noise: pnoise = np.random.normal(0, 1, len(phot)) * pnoise_sigma mock['maggies'] = phot + pnoise else: mock['maggies'] = phot.copy() mock['maggies_unc'] = pnoise_sigma mock['mock_snr'] = snr mock['phot_mask'] = np.ones(len(phot), dtype=bool) # No spectrum mock['wavelength'] = None mock["spectrum"] = None return mock
def load_obs(objname=None, datloc=None, err_floor=0.05, **extras): ''' objname: number of object in the 3D-HST COSMOS photometric catalog err_floor: the fractional error floor (0.05 = 5% floor) zp_err: inflate the errors by the zeropoint offsets from Skelton+14 ''' ### open file, load data with open(datloc, 'r') as f: hdr = f.readline().split() dtype = np.dtype([(hdr[1],'S20')] + [(n, np.float) for n in hdr[2:]]) dat = np.loadtxt(datloc, comments = '#', dtype = dtype) ### extract filters, fluxes, errors for object obj_idx = (dat['ID'] == objname) filters = np.array([f[1:] for f in dat.dtype.names if f[0] == 'e']) flux = np.squeeze([dat[obj_idx][f] for f in filters]) unc = np.squeeze([dat[obj_idx]['e'+f] for f in filters]) ### define photometric mask, convert from Jy to maggies phot_mask = (flux != unc) & (flux != -99.0) & (unc > 0) maggies = flux / 3631 maggies_unc = unc / 3631 ### implement error floor maggies_unc = np.clip(maggies_unc, maggies*err_floor, np.inf) ### mask anything touching or bluewards of Ly-a zred = dat['zz'][obj_idx] fnames = [f+'_candels' for f in filters] translate = { 'f24_candels':'spitzer_mips_24', 'f70_candels':'spitzer_mips_70', 'f100_candels':'herschel_pacs_100', 'f160_candels':'herschel_pacs_160', 'f250_candels':'herschel_spire_250' } fnames = [translate[f] if f in translate.keys() else f for f in fnames] ofilters = observate.load_filters(fnames) wavemax = np.array([f.wavelength[f.transmission > (f.transmission.max()*0.1)].max() for f in ofilters]) / (1+zred) wavemin = np.array([f.wavelength[f.transmission > (f.transmission.max()*0.1)].min() for f in ofilters]) / (1+zred) filtered = [1230] for f in filtered: phot_mask[(wavemax > f) & (wavemin < f)] = False phot_mask[wavemin < 1200] = False ### build output dictionary obs = {} obs['filters'] = ofilters obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def read_hdf5(filename, **extras): """Read an HDF5 file (with a specific format) into a dictionary of results. This HDF5 file is assumed to have the groups ``sampling`` and ``obs`` which respectively contain the sampling chain and the observational data used in the inference. All attributes of these groups as well as top-level attributes are loaded into the top-level of the dictionary using ``json.loads``, and therefore must have been written with ``json.dumps``. This should probably use JSONDecoders, but who has time to learn that. :param filename: Name of the HDF5 file. """ groups = {'sampling': {}, 'obs': {}} res = {} with h5py.File(filename, "r") as hf: # loop over the groups for group, d in groups.items(): # read the arrays in that group into the dictionary for that group for k, v in hf[group].items(): d[k] = np.array(v) # unserialize the attributes and put them in the dictionary for k, v in hf[group].attrs.items(): try: d[k] = json.loads(v) except: try: d[k] = unpick(v) except: d[k] = v # do top-level attributes. for k, v in hf.attrs.items(): try: res[k] = json.loads(v) except: try: res[k] = unpick(v) except: res[k] = v res.update(groups['sampling']) res['obs'] = groups['obs'] try: res['obs']['filters'] = load_filters([str(f) for f in res['obs']['filters']]) except: pass try: res['rstate'] = unpick(res['rstate']) except: pass try: mp = [names_to_functions(p.copy()) for p in res['model_params']] res['model_params'] = mp except: pass return res
def load_obs_mmt(filename=None, objname=None, #dist = 1e-5, vel = 0.0, wlo=3750., whi=7200., verbose=False, phottable='data/f2_apcanfinal_6phot_v2.fits', **kwargs): """ Read one of Caldwell's MMT spectra and find the matching PHAT photometry, return a dictionary containing the observations. """ from sedpy import observate obs ={} ####### SPECTRUM ####### if verbose: print('Loading data from {0}'.format(filename)) scale = 1e0 #testing #fluxconv = np.pi * 4. * (dist * 1e6 * pc)**2 / lsun #erg/s/AA/cm^2 to L_sun/AA fluxconv = 1.0#5.0e-20 * scale #approximate counts to erg/s/AA/cm^2 #redshift = 0.0 #vel / 2.998e8 dat = np.squeeze(pyfits.getdata(filename)) hdr = pyfits.getheader(filename) crpix = (hdr['CRPIX1'] -1) #convert from FITS to numpy indexing try: cd = hdr['CDELT1'] except (KeyError): cd = hdr['CD1_1'] obs['wavelength'] = (np.arange(dat.shape[1]) - crpix) * cd + hdr['CRVAL1'] obs['spectrum'] = dat[0,:] * fluxconv obs['unc'] = np.sqrt(dat[1,:]) * fluxconv #Masking. should move to a function that reads a mask definition file #one should really never mask in the rest frame - that should be modeled! obs['mask'] = ((obs['wavelength'] >= wlo ) & (obs['wavelength'] <= whi)) obs['mask'] = obs['mask'] & ((obs['wavelength'] <= 5570) | (obs['wavelength'] >= 5590)) #mask OI sky line obs['mask'] = obs['mask'] & ((obs['wavelength'] <= 6170) | (obs['wavelength'] >= 6180)) #mask...something. #obs['wavelength'] /= (1.0 + redshift) ######## PHOTOMETRY ######## if verbose: print('Loading mags from {0} for {1}'.format(phottable, objname)) mags, mags_unc, flag = query_phatcat(objname, phottable = phottable, **kwargs) obs['filters'] = observate.load_filters(['wfc3_uvis_'+b.lower() for b in ["F275W", "F336W", "F475W", "F814W"]] + ['wfc3_ir_'+b.lower() for b in ["F110W", "F160W"]]) obs['maggies'] = 10**(-0.4 * (mags - np.array([f.ab_to_vega for f in obs['filters']]) - 2.5*np.log10(scale) )) obs['maggies_unc'] = mags_unc * obs['maggies'] / 1.086 return obs
def zsfh_to_obs(sfhlist, zlist, lfbandnames=None, select_function=None, bandnames=None, sps=None, isocs=None, **kwargs): """ Go from a list of SFHs (one for each metallicity) to a broadband SED and set of luminosity functions for a stellar population. """ sed_values, lf_values = {}, [] #basti = np.any(sps.zlegend[0:2] == 0.0006) #Hack to check for Basti Isochrones nsfh = len(sfhlist) assert len(zlist) == nsfh ########### # SED ############ if bandnames is not None: filterlist = observate.load_filters(bandnames) spec, wave, mass = rsed.one_region_sed(copy.deepcopy(sfhlist), total_zmet, sps) mags = observate.getSED(wave, spec*rsed.to_cgs, filterlist=filterlist) maggies = 10**(-0.4 * np.atleast_1d(mags)) sed_values['sed_ab_maggies'] = maggies sed_values['sed_filters'] = bandnames ############# # LFs ############ #create the SSP CLFs, using nearest neighbor interpolation for the metallicity all_lf_base = [] bins = rsed.lfbins for i,zmet in enumerate(zlist): if isocs is not None: isoc = isocs[i] else: sps.params['zmet'] = np.abs(sps.zlegend - zmet).argmin() + 1 isoc = sps.isochrones() print("Using Zmet={0} in place of requested " "Zmet={1}".format(sps.zlegend[sps.params['zmet']-1],zmet)) ldat = isochrone_to_clfs(copy.deepcopy(isoc), lfbandnames, select_function=select_function, **kwargs) all_lf_base += [ldat] #use the SSP CLFs to generate a total LF (for each band) for i, band in enumerate(lfbandnames): lf_oneband = {} lf_base = [zbase[i] for zbase in all_lf_base] lfs_zt, lf, logages = rsed.one_region_lfs(copy.deepcopy(sfhlist), lf_base) lf_oneband['bandname'] = band lf_oneband['clf'] = lf lf_oneband['clf_mags'] = bins lf_oneband['logages'] = logages lf_oneband['clfs_zt'] = lfs_zt lf_values += [lf_oneband] ############# # Write output ############ return sed_values, lf_values
def ggc_mock(model, theta, sps, objname='', apply_cal=True, mask=True, add_noise=False, phot_snr=30, spec_snr=None, **extras): """Generate a mock spectrum """ mock = {} fnames = [ 'galex_FUV', 'galex_NUV', 'sdss_g0', 'sdss_r0', 'sdss_i0', 'sdss_z0', 'twomass_J', 'twomass_H', 'twomass_Ks' ] # load the calibrated spectrum cal = ggc_spec(objname, 'a', '1', fluxtype=None, **extras) if spec_snr is None: spec_snr = cal['spectrum'] / cal['unc'] mock['filters'] = observate.load_filters(fnames) mock['wavelength'] = cal['wavelength'] mock['sky'] = cal['sky'] s, p, x = model.sed(theta, mock, sps=sps) mock['intrinsic_true_spectrum'] = s.copy() mock['intrinsic_true_maggies'] = p.copy() mock['mock_params'] = model.params mock['mock_theta'] = model.theta.copy() mock['calibration'], noise = 1.0, 0.0 mock['added_noise'] = None if apply_cal: s *= cal['calibration'] mock['calibration'] = cal['calibration'].copy() noise_sigma = s / spec_snr pnoise_sigma = p / phot_snr if add_noise: noise = np.random.normal(0, 1, len(s)) * noise_sigma s += noise.copy() mock['added_noise'] = noise.copy() pnoise = np.random.normal(0, 1, len(p)) * pnoise_sigma p += pnoise.copy() mock['added_phot_noise'] = pnoise.copy() mock['spectrum'] = s mock['maggies'] = p # Should use s/spec_snr??? no, that does not actually give the # likelihood of the mock data given the model and the uncertainty mock['unc'] = noise_sigma mock['maggies_unc'] = pnoise_sigma if mask: mock = ggc_mask(mock) return mock
def load_obs(objid=0, phottable=photfile, **kwargs): """Load photometry from an ascii file. Assumes the following columns: `objid`, `filterset`, [`mag0`,....,`magN`] where N >= 11. The User should modify this function (including adding keyword arguments) to read in their particular data format and put it in the required dictionary. :param objid: The object id for the row of the photomotery file to use. Integer. Requires that there be an `objid` column in the ascii file. :param phottable: Name (and path) of the ascii file containing the photometry. :returns obs: Dictionary of observational data. """ from astropy.io import ascii # Writes your code here to read data. Can use FITS, h5py, astropy.table, # sqlite, whatever. # NO YOU CANT YOU CANT USE .DAT SO DON'T WHATEVER ME, MISTER # e.g.: import astropy.io.fits as pyfits #catalog = pyfits.getdata(phottable) global catalog catalog = ascii.read(phottable) #ind = catalog['objid'] == float(objid) # Pick up data from our file, yo. wavelengths = [475,814,1600] mags = np.array([catalog['f_{}'.format(i)] for i in wavelengths]) ivars = np.array([catalog['ivar_{}'.format(i)] for i in wavelengths]) ids = catalog['ID'] zs = catalog['z'] # Build output dictionary. obs = {} # This is a list of sedpy filter objects. See the # sedpy.observate.load_filters command for more details on its syntax. obs['filters'] = load_filters(filtersets) # sg_flux feeds nanomaggies, oops obs['all_maggies'] = np.squeeze(mags*10**(-9)) #obs['maggies_unc'] = np.squeeze(ivars*10**(-9)) #obs['maggies'] = np.squeeze(10**(-mags/2.5)) obs['all_maggies_unc'] = obs['all_maggies'] * 0.07 # Here we mask out any NaNs or infs obs['all_phot_mask'] = np.isfinite(np.squeeze(mags)) # We have no spectrum. obs['wavelength'] = None obs['objid'] = ids obs['z'] = zs obs['spectrum'] = None obs['logify_spectrum'] = False return obs '''
def load_obs(snr=10.0, filterset=["sdss_g0", "sdss_r0"], add_noise=True, **kwargs): """Make a mock dataset. Feel free to add more complicated kwargs, and put other things in the run_params dictionary to control how the mock is generated. :param snr: The S/N of the phock photometry. This can also be a vector of same lngth as the number of filters. :param filterset: A list of `sedpy` filter names. Mock photometry will be generated for these filters. :param add_noise: (optional, boolean, default: True) If True, add a realization of the noise to the mock spectrum """ # We'll put the mock data in this dictionary, just as we would for real # data. But we need to know which bands (and wavelengths if doing # spectroscopy) in which to generate mock data. mock = {} mock['wavelength'] = None # No spectrum mock['filters'] = load_filters(filterset) # # We need the models to make a mock sps = load_sps(**kwargs) mod = load_model(**kwargs) # Now we get the mock params from the kwargs dict params = {} for p in mod.params.keys(): if p in kwargs: params[p] = np.atleast_1d(kwargs[p]) # And build the mock mod.params.update(params) spec, phot, _ = mod.mean_model(mod.theta, mock, sps=sps) # Now store some output mock['true_spectrum'] = spec.copy() mock['true_maggies'] = phot.copy() mock['mock_params'] = deepcopy(mod.params) # And add noise pnoise_sigma = phot / snr if add_noise: pnoise = np.random.normal(0, 1, len(phot)) * pnoise_sigma mock['maggies'] = phot + pnoise else: mock['maggies'] = phot.copy() mock['maggies_unc'] = pnoise_sigma mock['mock_snr'] = snr mock['phot_mask'] = np.ones(len(phot), dtype=bool) return mock
def load_models(self): """Load the Draine & Li basis models, initialize the grid to hold resampled models, and load the filters """ # Draine and Li Basis self.dl07 = dustmodel.DraineLi() # object to hold the model grid self.dustgrid = dustmodel.SpecLibrary() # filter objects self.filterlist = observate.load_filters(self.rp['fnamelist'])
def build_obs(**kwargs): from hyperion.model import ModelOutput from astropy import units as u from astropy import constants print('galaxy: ', sys.argv[1]) m = ModelOutput( "/ufrc/narayanan/s.lower/pd_runs/simba_m25n512/snap305_dustscreen/snap305/snap305.galaxy" + str(sys.argv[1]) + ".rtout.sed") wav, flux = m.get_sed(inclination=0, aperture=-1) wav = np.asarray(wav) * u.micron #wav is in micron wav = wav.to(u.AA) flux = np.asarray(flux) * u.erg / u.s dl = (10. * u.pc).to(u.cm) flux /= (4. * 3.14 * dl**2.) nu = constants.c.cgs / (wav.to(u.cm)) nu = nu.to(u.Hz) flux /= nu flux = flux.to(u.Jy) maggies = flux / 3631. filters_unsorted = load_filters(filternames) waves_unsorted = [x.wave_mean for x in filters_unsorted] filters = [x for _, x in sorted(zip(waves_unsorted, filters_unsorted))] flx = [] flxe = [] for i in range(len(filters)): flux_range = [] wav_range = [] for j in filters[i].wavelength: flux_range.append(maggies[find_nearest(wav.value, j)].value) wav_range.append(wav[find_nearest(wav.value, j)].value) a = np.trapz(wav_range * filters[i].transmission * flux_range, wav_range, axis=-1) b = np.trapz(wav_range * filters[i].transmission, wav_range) flx.append(a / b) flxe.append(0.03 * flx[i]) flx = np.asarray(flx) flxe = np.asarray(flxe) flux_mag = flx unc_mag = flxe obs = {} obs['filters'] = filters obs['maggies'] = flux_mag obs['maggies_unc'] = unc_mag obs['phot_mask'] = np.isfinite(flux_mag) obs['wavelength'] = None obs['spectrum'] = None return obs
def test_photometry_and_transferfunctions(): filternames = ["decam_g", "decam_r", "decam_z"] filterdir = "data/filters" filter_list = observate.load_filters(filternames, directory=filterdir) lambda_aa, f_lambda_aa = load_test_sed() speedoflight = 3e18 f_nu_aa = f_lambda_aa * lambda_aa**2 / speedoflight redshift_grid = np.linspace(0.0, 2, 2)[1:] redshifted_fluxes, redshifted_fluxes2, redshift_factor = get_redshifted_photometry( lambda_aa, f_lambda_aa, redshift_grid, filter_list) relative_accuracy = 0.01 assert np.allclose(redshifted_fluxes, redshifted_fluxes2, rtol=relative_accuracy) ( transfer_functions_f_lambda, redshift_factor4, ) = build_restframe_photometric_transferfunction(redshift_grid, lambda_aa, filter_list, f_lambda=True) ( transfer_functions_f_nu, redshift_factor5, ) = build_restframe_photometric_transferfunction(redshift_grid, lambda_aa, filter_list, f_lambda=False) redshifted_fluxes4 = np.sum(transfer_functions_f_lambda * f_lambda_aa[None, :, None], axis=1) redshifted_fluxes5 = np.sum(transfer_functions_f_nu * f_nu_aa[None, :, None], axis=1) rtol, atol = 1e-5, 1e-8 assert np.allclose(redshifted_fluxes, redshifted_fluxes4, rtol=rtol, atol=atol) assert np.allclose(redshift_factor, redshift_factor4, rtol=rtol, atol=atol) assert np.allclose(redshifted_fluxes, redshifted_fluxes5, rtol=rtol, atol=atol) assert np.allclose(redshift_factor, redshift_factor5, rtol=rtol, atol=atol)
def read_results(filename): res, obs, mod = reader.results_from(path_res + filename) # update data table res['run_params']['data_table'] = path_wdir + 'data/halo7d_with_phot.fits' mod = reader.get_model(res) # update filters filternames = [str(ii) for ii in obs['filters']] obs['filters'] = load_filters(filternames, directory=filter_folder) # load sps sps = reader.get_sps(res) return (res, obs, mod, sps)
def load_obs(snr=10.0, filterset=["sdss_g0", "sdss_r0"], add_noise=True, **kwargs): """Make a mock dataset. Feel free to add more complicated kwargs, and put other things in the run_params dictionary to control how the mock is generated. :param snr: The S/N of the phock photometry. This can also be a vector of same lngth as the number of filters. :param filterset: A list of `sedpy` filter names. Mock photometry will be generated for these filters. :param add_noise: (optional, boolean, default: True) If True, add a realization of the noise to the mock spectrum """ # We'll put the mock data in this dictionary, just as we would for real # data. But we need to know which bands (and wavelengths if doing # spectroscopy) in which to generate mock data. mock = {} mock['wavelength'] = None # No spectrum mock['filters'] = load_filters(filterset) # # We need the models to make a mock sps = load_sps(**kwargs) mod = load_model(**kwargs) # Now we get the mock params from the kwargs dict params = {} for p in mod.params.keys(): if p in kwargs: params[p] = np.atleast_1d(kwargs[p]) # And build the mock mod.params.update(params) spec, phot, _ = mod.mean_model(mod.theta, mock, sps=sps) # Now store some output mock['true_spectrum'] = spec.copy() mock['true_maggies'] = phot.copy() mock['mock_params'] = deepcopy(mod.params) # And add noise pnoise_sigma = phot / snr if add_noise: pnoise = np.random.normal(0, 1, len(phot)) * pnoise_sigma mock['maggies'] = phot + pnoise else: mock['maggies'] = phot.copy() mock['maggies_unc'] = pnoise_sigma mock['mock_snr'] = snr mock['phot_mask'] = np.ones(len(phot), dtype=bool) return mock
def load_obs(filter_key=1, **extras): # what are our mock parameters? params = { 'logmass': 10, 'logzsol': -0.75, 'logsfr_ratios': np.array([0.15,0.15,0.15,0.15,0.15,0.15]), # hacked, gently rising 'dust2': 0.5, 'dust1_fraction': 0.9, 'fagn': 0.05, 'agn_tau': 20, 'duste_qpah': 0.5, 'duste_umin': 2, 'duste_gamma': 0.2, 'dust_index': -0.3 } for p in params.keys(): params[p] = np.atleast_1d(params[p]) # what are our filters? filters = find_filters(filter_key) # load model, sps mod = load_model(**run_params) sps = load_sps(**run_params) # we will also need an obs dictionary obs = {} obs['filters'] = observate.load_filters(filters) obs['wavelength'] = None # signal to noise ratio snr = 20 if filter_key == 10: snr = np.array([np.repeat(10,10).tolist() + [4]]) # Generate the photometry, add noise mod.params.update(params) spec, maggies, _ = mod.mean_model(mod.theta, obs, sps=sps) maggies_unc = np.atleast_1d((maggies / snr).squeeze()) phot_mask = np.ones_like(maggies,dtype=bool) ### build output dictionary obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['spectrum'] = None obs['logify_spectrum'] = False obs['true_params'] = params obs['true_spec'] = spec return obs
def project_filter(wave, spectrum, bands=["sdss_r0"]): """ :param wave: Wavelengths in angstroms ndarray of shape (nw,) :param spectrum: Spectrum, in units of f_lambda (magnitudes will be correct if they are units of erg/s/cm^2). same shape as `wave` """ filters = load_filters(bands) mags = getSED(wave, spectrum, filterlist=filters) return mags
def load_obs_lris( filename=None, objname=None, #dist = 1e-5, vel = 0.0, wlo=3550., whi=5500., verbose=False, phottable='data/f2_apcanfinal_6phot_v2.fits', **kwargs): """ Read one of the Keck LRIS spectra and find the matching PHAT photometry, return a dictionary containing the observations. """ from sedpy import observate obs = {} ####### SPECTRUM ####### if verbose: print('Loading data from {0}'.format()) #fluxconv = np.pi * 4. * (dist * 1e6 * pc)**2 / lsun #erg/s/AA/cm^2 to L_sun/AA fluxconv = 1.0 scale = 1e0 #testing #redshift = vel / 2.998e8 dat = pyfits.getdata(filename) hdr = pyfits.getheader(filename) obs['wavelength'] = dat[0]['wave_opt'] obs['spectrum'] = dat[0]['spec'] obs['unc'] = 1. / np.sqrt(dat[0]['ivar']) #masking obs['mask'] = ((obs['wavelength'] >= wlo) & (obs['wavelength'] <= whi)) #obs['wavelength'] /= (1.0 + redshift) ######## PHOTOMETRY ###### if verbose: print('Loading mags from {0} for {1}'.format(phottable, objname)) mags, mags_unc, flag = query_phatcat(objname, phottable=phottable, **kwargs) obs['filters'] = observate.load_filters([ 'wfc3_uvis_' + b.lower() for b in ["F275W", "F336W", "F475W", "F814W"] ] + ['wfc3_ir_' + b.lower() for b in ["F110W", "F160W"]]) obs['maggies'] = 10**( -0.4 * (mags - np.array([f.ab_to_vega for f in obs['filters']]) - 2.5 * np.log10(scale))) obs['maggies_unc'] = mags_unc * obs['maggies'] / 1.086 return obs
def build_obs(objid=objid, phottable=None, luminosity_distance=None, **kwargs): from prospect.utils.obsutils import fix_obs wl, flux, flux_err = prospector_wl_flux(path_spec, path_err) maggies, emaggies = phot_maggies(work_df_uvista) obs = {} filternames = [ "UVISTA_Ks", "UVISTA_H", "UVISTA_J", "UVISTA_Y", "IB427.SuprimeCam", "IB464.SuprimeCam", "IB484.SuprimeCam", "IB505.SuprimeCam", "IB527.SuprimeCam", "IB574.SuprimeCam", "IB624.SuprimeCam", "IB679.SuprimeCam", "IB709.SuprimeCam", "IB738.SuprimeCam", "IB767.SuprimeCam", "IB827.SuprimeCam", "spitzer_irac_ch1", "spitzer_irac_ch2", "spitzer_irac_ch3", "spitzer_irac_ch4", #"spitzer_mips_24", "galex_FUV", "galex_NUV", "u_megaprime_sagem", "B_subaru", "V_subaru", "g_subaru", "r_subaru", "i_subaru", "z_subaru", ] obs['filters'] = load_filters(filternames) obs['maggies'] = maggies floor_phot = 0.05 * obs['maggies'] obs['maggies_unc'] = np.clip(emaggies, floor_phot, np.inf) obs['wavelength'] = wl obs['spectrum'] = flux floor_spec = 0.01 * obs['spectrum'] obs['unc'] = np.clip(flux_err, floor_spec, np.inf) obs['objid'] = objid obs = fix_obs(obs) return obs
def median_by_band(x,y,avg=False,log=False): ##### get filter effective wavelengths for sorting delz = 0.15 from brownseds_np_params import translate_filters from sedpy import observate filtnames = np.array(translate_filters(0,full_list=True)) filts = observate.load_filters(filtnames[filtnames != 'nan']) wave_effective = np.array([filt.wave_effective for filt in filts])/1e4 wave_effective.sort() ### remove overlapping filters ### and ones outside the plot delta_lam = 0.06 for i in range(wave_effective.shape[0]): if i >= wave_effective.shape[0]: continue if ((np.abs(1-wave_effective/wave_effective[i]) < delta_lam).sum() > 1): wave_effective = np.delete(wave_effective,i) wave_effective = wave_effective[wave_effective < 25] avglam, outval, outval_up, outval_down, outval_upup, outval_downdown = [np.array([]) for i in range(6)] for lam in wave_effective: #in_bounds = (x <= lam) & (x > lam/(1+delz)) in_bounds = (np.abs(1-lam/x) < delta_lam) avglam = np.append(avglam, np.mean(x[in_bounds])) mid, top, bot, toptop, botbot = np.percentile(y[in_bounds], [50, 84, 16, 95, 5]) outval_up = np.append(outval_up, top) outval_down = np.append(outval_down, bot) outval_upup = np.append(outval_upup, toptop) outval_downdown = np.append(outval_downdown, botbot) if avg: mean, sig = y[in_bounds].mean(), np.std(y[in_bounds]) outval = np.append(outval, mean) #outval_up = np.append(outval_up, mean+sig) #outval_down = np.append(outval_down, mean-sig) #outval_upup = np.append(outval_upup, mean+2*sig) #outval_downdown = np.append(outval_downdown, mean-2*sig) else: outval = np.append(outval, mid) if log: return avglam, -np.log10(1-outval), -np.log10(1-outval_up), -np.log10(1-outval_down), -np.log10(1-outval_upup), -np.log10(1-outval_downdown) else: return avglam, outval, outval_up, outval_down, outval_upup, outval_downdown
def load_obs(objname=None, datdir=None, runname=None, err_floor=0.05, zperr=True, no_zp_corrs=False, **extras): ''' objname: number of object in the 3D-HST COSMOS photometric catalog err_floor: the fractional error floor (0.05 = 5% floor) zp_err: inflate the errors by the zeropoint offsets from Skelton+14 ''' filters = ['f1000w_miri','f1280w_miri','f1500w_miri','f1800w_miri','f2100w_miri','mips_24um_aegis'] obs = {'maggies': None, 'phot_mask': np.ones_like(filters), 'wavelength': None, 'filters': observate.load_filters(filters)} return obs
def load_obs(snr=10, out_of_priors=False, **extras): # if we want to generate observations of a low metallicity galaxy with a rising SFH instead # this is not in our allowed parameter space! if out_of_priors: from example3_params import load_obs as load_obs_ex3 return load_obs_ex3() # what are our mock parameters? params = { 'logmass': 10, 'logzsol': -0.25, 'dust2': 0.5, 'logtau': 1.0, 'tage': 8 } for p in params.keys(): params[p] = np.atleast_1d(params[p]) # will need model and sps object to generate photometry mod = load_model(out_of_priors=out_of_priors, **run_params) sps = load_sps(**run_params) # we will also need filters obs = {} filters = [ 'sdss_u0', 'sdss_g0', 'sdss_r0', 'sdss_i0', 'twomass_J', 'twomass_H', 'twomass_Ks' ] obs['filters'] = observate.load_filters(filters) obs['wavelength'] = None # generate the photometry, add noise mod.params.update(params) spec, maggies, _ = mod.mean_model(mod.theta, obs, sps=sps) maggies_unc = (maggies / snr).squeeze() phot_mask = np.ones_like(maggies, dtype=bool) # finishing building obs dictionary obs['wave_effective'] = np.array( [filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['spectrum'] = None obs['true_params'] = params obs['true_spec'] = spec return obs
def load_obs(photname, objname, err_floor=0.05, zperr=True, **extras): ''' photname: photometric file location objname: number of object in the 3D-HST COSMOS photometric catalog err_floor: the fractional error floor (0.05 = 5% floor) zp_err: inflate the errors by the zeropoint offsets from Skelton+14 ''' # OPEN FILE, LOAD DATA with open(photname, 'r') as f: hdr = f.readline().split() dtype = np.dtype([(hdr[1], 'S20')] + [(n, np.float) for n in hdr[2:]]) dat = np.loadtxt(photname, comments='#', delimiter=' ', dtype=dtype) # EXTRACT FILTERS, FLUXES, ERRORS FOR OBJECT obj_idx = (dat['id'] == objname) # print(dat[obj_idx]['id'], 'idx') filters = np.array( filts) # [f[2:] for f in dat.dtype.names if f[0:2] == 'f_']) flux = np.squeeze([dat[obj_idx]['f_' + f] for f in filternames]) unc = np.squeeze([dat[obj_idx]['e_' + f] for f in filternames]) # DEFINE PHOTOMETRIC MASK< CONVERT TO MAGGIES phot_mask = (flux != -99.0) maggies = flux * 10**-6 / 3631 # flux [uJy] * 1e-6 [Jy / uJy] * 1 [maggy] / 3631 [Jy] maggies_unc = unc * 10**-6 / 3631 # print(maggies, 'maggies') # print(flux, 'flux') # print(maggies_unc, 'maggies_unc') # print(unc, 'unc') # ERROR FLOOR maggies_unc = np.clip( maggies_unc, maggies * err_floor, np.inf) # for any unc < err_floor, replace with err_floor # BUILD OUTPUT DICTIONARY obs = {} obs['filters'] = observate.load_filters(filters) obs['wave_effective'] = np.array( [filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def build_obs(**kwargs): sps = build_sps() mod = build_model() fake_obs = {'filters': load_filters(filternames), 'wavelength': None} mod.params['dust_type'] = 0 # non-KC attenuation curve #mod.params['dust1'] = 1.0 initial_theta = mod.initial_theta.copy() initial_theta[mod.theta_labels().index('dust2')] = 1.5 initial_theta[mod.theta_labels().index('logzsol')] = 0.0 initial_theta[mod.theta_labels().index('tage')] = 2.0 spec, mags, stellar_mass = mod.mean_model(initial_theta, sps=sps, obs=fake_obs) obs = {} obs['maggies'] = mags obs['filters'] = load_filters(filternames) obs['maggies_unc'] = mags * 0.1 obs['phot_mask'] = np.isfinite(mags) obs['wavelength'] = None obs['spectrum'] = None return obs
def load_obs(photname, objname, err_floor=0.05, zperr=True, **extras): ''' photname: photometric file location objname: number of object in the 3D-HST COSMOS photometric catalog err_floor: the fractional error floor (0.05 = 5% floor) zp_err: inflate the errors by the zeropoint offsets from Skelton+14 ''' ### open file, load data with open(photname, 'r') as f: hdr = f.readline().split() dtype = np.dtype([(hdr[1], 'S20')] + [(n, np.float) for n in hdr[2:]]) dat = np.loadtxt(photname, comments='#', delimiter=' ', dtype=dtype) ### extract filters, fluxes, errors for object # from ReadMe: "All fluxes are normalized to an AB zeropoint of 25, such that: magAB = 25.0-2.5*log10(flux) obj_idx = (dat['id'] == objname) # print(dat[obj_idx]['id'], 'idx') filters = np.array( filts) # [f[2:] for f in dat.dtype.names if f[0:2] == 'f_']) flux = np.squeeze([dat[obj_idx]['f_' + f] for f in filternames]) unc = np.squeeze([dat[obj_idx]['e_' + f] for f in filternames]) ### define photometric mask, convert to maggies phot_mask = (flux != -99.0) maggies = flux * 10**-6 / 3631 # flux [uJy] * 1e-6 [Jy / uJy] * 1 [maggy] / 3631 [Jy] maggies_unc = unc * 10**-6 / 3631 # print(maggies, 'maggies') # print(flux, 'flux') # print(maggies_unc, 'maggies_unc') # print(unc, 'unc') ### implement error floor maggies_unc = np.clip(maggies_unc, maggies * err_floor, np.inf) ### build output dictionary obs = {} obs['filters'] = observate.load_filters(filters) obs['wave_effective'] = np.array( [filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def do_all(runname='vis', outfolder=None,**opts): if outfolder is None: outfolder = os.getenv('APPS') + '/prospector_alpha/plots/'+runname+'/vis_plots/' if not os.path.isdir(outfolder): os.makedirs(outfolder) os.makedirs(outfolder+'data/') data = collate_data(runname,filename=outfolder+'data/dat.h5',**opts) for i in range(len(data['filters'])): data['filters'][i] = load_filters(data['filters'][i]) if runname == 'vis': data['mod'] = vis_params.load_model(**vis_params.run_params) else: data['mod'] = vis_expsfh_params.load_model(**vis_expsfh_params.run_params) plot_addfilts(data,outfolder,runname)
def load_obs_lris(filename=None, objname=None, #dist = 1e-5, vel = 0.0, wlo=3550., whi=5500., verbose=False, phottable='data/f2_apcanfinal_6phot_v2.fits', **kwargs): """ Read one of the Keck LRIS spectra and find the matching PHAT photometry, return a dictionary containing the observations. """ from sedpy import observate obs ={} ####### SPECTRUM ####### if verbose: print('Loading data from {0}'.format()) #fluxconv = np.pi * 4. * (dist * 1e6 * pc)**2 / lsun #erg/s/AA/cm^2 to L_sun/AA fluxconv = 1.0 scale = 1e0 #testing #redshift = vel / 2.998e8 dat = pyfits.getdata(filename) hdr = pyfits.getheader(filename) obs['wavelength'] = dat[0]['wave_opt'] obs['spectrum'] = dat[0]['spec'] obs['unc'] = 1./np.sqrt(dat[0]['ivar']) #masking obs['mask'] = ((obs['wavelength'] >= wlo ) & (obs['wavelength'] <= whi)) #obs['wavelength'] /= (1.0 + redshift) ######## PHOTOMETRY ###### if verbose: print('Loading mags from {0} for {1}'.format(phottable, objname)) mags, mags_unc, flag = query_phatcat(objname, phottable = phottable, **kwargs) obs['filters'] = observate.load_filters(['wfc3_uvis_'+b.lower() for b in ["F275W", "F336W", "F475W", "F814W"]] + ['wfc3_ir_'+b.lower() for b in ["F110W", "F160W"]]) obs['maggies'] = 10**(-0.4 * (mags - np.array([f.ab_to_vega for f in obs['filters']]) - 2.5*np.log10(scale) )) obs['maggies_unc'] = mags_unc * obs['maggies'] / 1.086 return obs
def load_phot(phot, unit): """ Return the photometry in a prospector compatible unit and format. Parameters ---------- phot : [dict or pandas.DataFrame] Photometry to convert and load in prospector. unit : [string] Photometry's unit. Can be: - "Hz": erg/s/cm2/Hz - "AA": erg/s/cm2/AA - "mgy": maggies - "Jy": Jansky - "mag": magnitudes Returns ------- dict """ if phot is None: return phot from sedpy.observate import load_filters _data = phot.copy() _filters = keys_to_filters(_data.keys()) _phot = np.array([float(_data[_filt]) for _filt in _filters]) _dphot = np.array([float(_data[_filt + ".err"]) for _filt in _filters]) _lbda = np.array([ _filt.wave_effective for _filt in load_filters(filters_to_pysed(_filters)) ]) if unit == "mag": _phot, _dphot = tools.mag_to_flux(_phot, _dphot, _lbda, inhz=True) unit = "Hz" _phot, _dphot = tools.convert_flux_unit([_phot, _dphot], unit, "mgy", _lbda) _out = {_filt: _phot[ii] for ii, _filt in enumerate(_filters)} _out.update( {_filt + ".err": _dphot[ii] for ii, _filt in enumerate(_filters)}) return _out
def build_obs(binNum=0, infile=None, **extras): import numpy as np from astropy.table import Table from sedpy.observate import load_filters from prospect.utils.obsutils import fix_obs table = Table.read(infile) flux_columns = [col for col in table.colnames if col.endswith('_flux')] e_flux_columns = [col.replace('flux', 'err') for col in flux_columns] nPix_columns = [col.replace('flux', 'nPix') for col in flux_columns] use_columns = [col.replace('flux', 'use') for col in flux_columns] filternames = ['hff_' + col.replace('_flux', '') for col in flux_columns] fluxes = np.array(list(table[flux_columns][binNum])) / 3631 # in maggies e_fluxes = np.array(list( table[e_flux_columns][binNum])) / 3631 # in maggies nPixels = np.array(list(table[nPix_columns][binNum])) use_col = np.array(list(table[use_columns][binNum])) fluxes_per_pixel = fluxes / nPixels e_fluxes_per_pixel = e_fluxes / nPixels max_SNR = 20 SNR_acceptable = (fluxes_per_pixel / e_fluxes_per_pixel < max_SNR) e_fluxes_per_pixel[ ~SNR_acceptable] = fluxes_per_pixel[~SNR_acceptable] / max_SNR obs = {} obs['filters'] = load_filters(filternames) obs['maggies'], obs['maggies_unc'] = fluxes_per_pixel, e_fluxes_per_pixel obs['phot_mask'] = use_col obs['phot_wave'] = np.array([f.wave_effective for f in obs['filters']]) obs['wavelength'], obs['spectrum'] = None, None obs['unc'], obs['mask'] = None, None obs['binNum'], obs['nPixels'] = binNum, nPixels obs = fix_obs(obs) return obs
def load_obs(photname='', objname='', **extras): """ Custom-built because the photometric files are actually generated by the model """ obs ={} filters = translate_filters() # build output dictionary obs['filters'] = observate.load_filters(filters) obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = np.ones_like(filters,dtype=bool) obs['maggies'] = np.ones_like(filters,dtype=float) obs['maggies_unc'] = np.ones_like(filters,dtype=float) obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def observe(fnames): # units: lambda (A), flux: fnu normalized to unity dat = load_data() filters = load_filters(fnames) out = {} for name in dat.dtype.names: if name == 'blank' or name == 'lambda': continue # sourcewave: Spectrum wavelength (in AA), ndarray of shape (nwave). # sourceflux: Associated flux (assumed to be in erg/s/cm^2/AA), ndarray of shape (nsource,nwave). # filterlist: List of filter objects, of length nfilt. # array of AB broadband magnitudes, of shape (nsource, nfilter). out[name] = getSED(dat['lambda'], (lightspeed/dat['lambda']**2)*dat[name], filters) return out
def rectify_basis(wave, spectra, wlow=0, whigh=np.inf, exclude=[], outwave=None, filters=None, **extras): """Mask a spectral basis using lists of include and exclude ranges """ if filters is not None: flist = observate.load_filters(filters) sed = observate.getSED(wave, spectra, filterlist=flist) return np.array([f.wave_effective for f in flist]), 10**(-0.4 * sed) if outwave is not None: onedinterp = interpolate(wave, spectra, axis=-1) spectra = onedinterp(outwave) wave = outwave g = (wave >= wlow) & (wave <= whigh) for (lo, hi) in exclude: g = g & ((wave < lo) | (wave > hi)) return wave[g], spectra[:, g]
def getobs(cat): """Generate the prospector-style "obs" dictionary which contains the input photometry, redshift, etc. for a single object. cat - fitsio structured array """ from sedpy.observate import load_filters obs = {} #updated for our project # Photometric bandpasses sdss = ['sdss_{}0'.format(b) for b in ['u', 'g', 'r', 'i', 'z']] wise = ['wise_{}'.format(b) for b in ['w1', 'w2']] filternames = sdss + wise obs['filternames'] = filternames obs['filters'] = load_filters(filternames) #updated for our project # Input photometry obs['maggies'] = np.squeeze(cat['MAGGIES']) mask = cat['IVARMAGGIES'] > 0 with np.errstate(invalid='ignore', divide='ignore'): obs['maggies_unc'] = np.squeeze(1.0 / np.sqrt(cat['IVARMAGGIES'])) #[:3, :]) obs['phot_mask'] = mask # Input spectroscopy (none for this dataset) obs['wavelength'] = None obs['spectrum'] = None obs['unc'] = None obs['mask'] = None #update, customize # Use initial values based on the iSEDfit results. obs['zred'] = cat['Z'] # redshift obs['mass'] = 10**cat['MSTAR'] # stellar mass obs['logzsol'] = np.log10(cat['ZMETAL'] / 0.019) # stellar metallicity obs['tage'] = cat['AGE'] # age obs['tau'] = cat['TAU'] # tau (for a delayed SFH) obs['dust2'] = 0.1 # Additional informational keys. obs['isedfit_id'] = cat['ISEDFIT_ID'] return obs
def load_obs(objname=None, datloc=None, err_floor=0.02, **extras): """ let's rock """ # open data dat = fits.open(datloc)[1].data # extract filters, fluxes, errors for object obj_idx = (dat['CATAID'] == int(objname)) filters = np.array([f[:-5] for f in dat.dtype.names if f[-4:] == 'flux']) flux = np.squeeze([dat[obj_idx][f+'_flux'] for f in filters]) unc = np.squeeze([dat[obj_idx][f+'_fluxerr'] for f in filters]) ### define photometric mask, convert from Jy to maggies phot_mask = (flux != -999.0) maggies = flux / 3631 maggies_unc = unc / 3631 ### implement error floor maggies_unc = np.clip(maggies_unc, maggies*err_floor, np.inf) ### mask anything touching or bluewards of Ly-a zred = dat['Z'][obj_idx] fnames = [trans[f] for f in filters] ofilters = observate.load_filters(fnames) wavemax = np.array([f.wavelength[f.transmission > (f.transmission.max()*0.1)].max() for f in ofilters]) / (1+zred) wavemin = np.array([f.wavelength[f.transmission > (f.transmission.max()*0.1)].min() for f in ofilters]) / (1+zred) filtered = [1230] for f in filtered: phot_mask[(wavemax > f) & (wavemin < f)] = False phot_mask[wavemin < 1200] = False ### build output dictionary obs = {} obs['filters'] = ofilters obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def load_obs(mock_key=1, **extras): """ let's rock """ # open photometric data to get filters dat = fits.open(run_params['datloc'])[1].data gama_fnames = np.array([f[:-5] for f in dat.dtype.names if f[-4:] == 'flux']) fnames = [trans[f] for f in gama_fnames] filters = observate.load_filters(fnames) phot_mask = np.ones_like(filters,dtype=bool) obs = {} obs['filters'] = filters obs['phot_mask'] = phot_mask obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False # generate mock parameters masses,agebins,names = set_masses(mock_key) model = load_model(agebins=agebins,**extras) itheta = model.initial_theta.copy() itheta[model.theta_index['mass']] = masses # determine S/N idx = np.in1d(dat['CATAID'],names.astype(np.int32)) sn = [] for f in gama_fnames: sn += [np.percentile(dat[f+'_flux'][idx]/dat[f+'_fluxerr'][idx],95)] sn = np.clip(sn,-np.inf,100) # generate photometry sps = load_sps(**extras) spec,maggies,sm = model.mean_model(itheta, obs, sps=sps) maggies_unc = maggies/sn obs['phot_mask'][sn == 1] = 0 # mask anything where S/N == 1 (this means median is nondetection!) ### build output dictionary obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['spec_true'] = spec obs['lam_true'] = sps.wavelengths return obs
def load_obs(snr=10, **extras): # what are our mock parameters? params = { 'logmass': 10, 'logzsol': -1.5, 'dust2': 0.05, 'logtau': 1.0, 'tage': 8 } for p in params.keys(): params[p] = np.atleast_1d(params[p]) # will need model and sps object to generate photometry mod = load_model(**run_params) sps = load_sps(**run_params) # we will also need filters obs = {} filters = [ 'sdss_u0', 'sdss_g0', 'sdss_r0', 'sdss_i0', 'twomass_J', 'twomass_H', 'twomass_Ks' ] obs['filters'] = observate.load_filters(filters) obs['wavelength'] = None # generate the photometry, add noise mod.params.update(params) spec, maggies, _ = mod.mean_model(mod.theta, obs, sps=sps) maggies_unc = (maggies / snr).squeeze() phot_mask = np.ones_like(maggies, dtype=bool) # finishing building obs dictionary obs['wave_effective'] = np.array( [filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['spectrum'] = None obs['true_params'] = params obs['true_spec'] = spec return obs
def load_obs(snr=10.0, add_noise=True, **kwargs): """Make a mock dataset. Feel free to add more complicated kwargs, and put other things in the run_params dictionary to control how the mock is generated. """ # We'll put the mock data in this dictionary, just as we would for real # data. But we need to know which filters (and wavelengths if doing # spectroscopy) with which to generate mock data. mock = {} mock['wavelength'] = None # No spectrum filterset = galex + sdss + spitzer[:2] # only warm spitzer mock['filters'] = load_filters(filterset) # We need the models to make a mock sps = load_sps(**kwargs) mod = load_model(**kwargs) # Now we get the mock params from the kwargs dict params = {} for p in mod.params.keys(): if p in kwargs: params[p] = np.atleast_1d(kwargs[p]) # And build the mock mod.params.update(params) spec, phot, _ = mod.mean_model(mod.theta, mock, sps=sps) # Now store some output mock['true_spectrum'] = spec.copy() mock['true_maggies'] = phot.copy() mock['mock_params'] = deepcopy(mod.params) # And add noise pnoise_sigma = phot / snr pnoise = np.random.normal(0, 1, len(phot)) * pnoise_sigma if add_noise: mock['maggies'] = phot + pnoise else: mock['maggies'] = phot.copy() mock['maggies_unc'] = pnoise_sigma mock['mock_snr'] = snr mock['phot_mask'] = np.ones(len(phot), dtype=bool) return mock
def load_galaxy_for_prospector(galaxy, filter_selection): all_filters = get_filters(filter_selection) valid_filters = [ f for f in all_filters if filter_has_valid_data(f, galaxy) ] if filter_selection == 'reliable' and len(valid_filters) != 12: raise ValueError( 'Some reliable bands are missing - only got {}'.format( valid_filters)) if filter_selection == 'euclid' and len(valid_filters) != 8: raise ValueError( 'Needs 8 valid Euclid bands - only got {}'.format(valid_filters)) logging.debug('valid filters: {}'.format(valid_filters)) maggies, maggies_unc = load_maggies_to_array(galaxy, valid_filters) # Instantiate the `Filter()` objects using methods in `sedpy` # prospector needs these filters = observate.load_filters([f.bandpass_file for f in valid_filters]) return filters, maggies, maggies_unc
def get_mags(wave,spectrum,z,lumdist,formed_mass,filterlist): # filter parameters filters = load_filters(filterlist) # redshift offset the spectrum a = 1+z wa, sa = wave*a, spectrum*a # get the absolute magnitudes mags = getSED(wa, lightspeed/wa**2 * sa * to_cgs, filters) phot = np.atleast_1d(10**(-0.4 * mags)) # get the observed magnitudes dfactor = (lumdist*1e5)**2 phot /= dfactor phot *= formed_mass phot = mgy_to_mag(phot) return phot
def load_obs(objname=None, datfile=None, **extras): # Read data from json with open(datfile,'r') as f: data = json.load(f) # pick out photometry information mag,err,fnames = [],[],[] for band in data[objname]['photometry']: fnames += [band['telescope'] + '_' + band['band']] mag += [float(band['mag'])] err += [float(band['err'])] # convert to maggies maggies = 10**((-2./5)*np.array(mag)) maggies_unc = np.array(err)*maggies/1.086 # photometric error floor (models aren't good to better than 5% or so anyway) maggies_unc = np.clip(maggies_unc, maggies*0.05, np.inf) # create mask, used to mask any bad photometry in the fit # here we don't know what "bad" photometry is, so it's a mask of ones. phot_mask = np.ones_like(maggies,dtype=bool) # translate photometric names into sedpy standards # note if we have any photometry redwards of rest-frame ~2um, # we need to turn on dust emission manually! filters = [translate[f] for f in fnames] ### build output dictionary obs = {} obs['filters'] = observate.load_filters(filters) obs['wave_effective'] = np.array([filt.wave_effective for filt in obs['filters']]) obs['phot_mask'] = phot_mask obs['maggies'] = maggies obs['maggies_unc'] = maggies_unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False return obs
def test(): from sedpy import observate import fsps import matplotlib.pyplot as pl filters = ['galex_NUV', 'sdss_u0', 'sdss_r0', 'sdss_r0', 'sdss_i0', 'sdss_z0', 'bessell_U', 'bessell_B', 'bessell_V', 'bessell_R', 'bessell_I', 'twomass_J','twomass_H'] flist = observate.load_filters(filters) sps = fsps.StellarPopulation(compute_vega_mags=False) wave, spec = sps.get_spectrum(tage=1.0, zmet=2, peraa=True) sed = observate.getSED(wave, spec, flist) sed_unc = np.abs(np.random.normal(1, 0.3, len(sed))) wgrid = np.linspace( 2e3, 13e3, 1000) fgrid = np.linspace( -13, -9, 100) psed, sedpoints = sed_to_psed(flist, sed, sed_unc, wgrid, fgrid) pl.imshow(np.exp(psed).T, cmap='Greys_r', interpolation='nearest', origin ='upper', aspect='auto')
def median_by_band(x,y,avg=False): ##### get filter effective wavelengths for sorting delz = 0.15 from brownseds_np_params import translate_filters from sedpy import observate filtnames = np.array(translate_filters(0,full_list=True)) filts = observate.load_filters(filtnames[filtnames != 'nan']) wave_effective = np.array([filt.wave_effective for filt in filts])/1e4 wave_effective.sort() avglam = np.array([]) outval = np.array([]) for lam in wave_effective: in_bounds = (x <= lam) & (x > lam/(1+delz)) avglam = np.append(avglam, np.mean(x[in_bounds])) if avg == False: outval = np.append(outval, np.median(y[in_bounds])) else: outval = np.append(outval, np.mean(y[in_bounds])) return avglam, outval
def load_obs(objname=None, noisefactor=1.0, calibrated=False, mask=True, broaden_obs=False, wlo=3750., whi=7500., **extras): assert objname == 'M67' bmag = 7.5 # hack obs = {} dat = np.loadtxt(os.path.join(sdir, 'data/m67_nobs.dat')) obs['wavelength'] = observate.vac2air(dat[:, 0]) obs['spectrum'] = dat[:, 1] obs['unc'] = dat[:, 2] obs['filters'] = observate.load_filters(['sdss_g0']) obs['maggies'] = np.array([10**(-0.4 * bmag)]) obs['maggies_unc'] = 0.05 * obs['maggies'] # mask obs['mask'] = (obs['wavelength'] > wlo) & (obs['wavelength'] < whi) #adjust uncertainties obs['unc'] *= noisefactor obs['noisefactor'] = noisefactor obs['spec_calibrated'] = calibrated return obs
def build_obs(filterlist=["sdss_r0"], snr=10, add_noise=True, seed=0, **run_params): """Build a mock observation """ from sedpy import observate filters = observate.load_filters(filterlist) mock = {"wavelength": None, "spectrum": None, "filters": filters} # Build the mock model sp = build_sps(**run_params) mod = build_model(**run_params) spec, phot, x = mod.mean_model(mod.theta, mock, sps=sp) # Add to dict with uncertainties pnoise_sigma = phot / snr mock['maggies'] = phot.copy() mock['maggies_unc'] = pnoise_sigma # And add noise if add_noise: if int(seed) > 0: np.random.seed(int(seed)) pnoise = np.random.normal(0, 1, len(phot)) * pnoise_sigma mock['maggies'] += pnoise # Ancillary info mock['true_spectrum'] = spec.copy() mock['true_maggies'] = phot.copy() mock['mock_params'] = deepcopy(mod.params) mock['mock_snr_phot'] = snr mock['phot_wave'] = np.array([f.wave_effective for f in mock['filters']]) obs = mock return obs
def load_obs(photname='', extinctname='', herschname='', objname='', **extras): """ let's do this """ obs ={} # load photometry hdulist = fits.open(photname) # find object if objname is not None: idx = hdulist[1].data['Name'] == objname else: idx = np.ones(len(hdulist[1].data['Name']),dtype=bool) # extract fluxes+uncertainties for all objects mag_fields = [f for f in hdulist[1].columns.names if (f[0:2] != 'e_') and (f != 'Name')] magunc_fields = [f for f in hdulist[1].columns.names if f[0:2] == 'e_'] # extract fluxes for particular object mag = np.array([np.squeeze(hdulist[1].data[f][idx]) for f in mag_fields]) magunc = np.array([np.squeeze(hdulist[1].data[f][idx]) for f in magunc_fields]) # extinctions extinct = fits.open(extinctname) extinctions = np.array([np.squeeze(extinct[1].data[f][idx]) for f in extinct[1].columns.names if f != 'Name']) # adjust fluxes for extinction # then convert to maggies mag_adj = mag - extinctions flux = 10**((-2./5)*mag_adj) # convert uncertainty to maggies unc = magunc*flux/1.086 #### Herschel photometry herschel = fits.open(herschname) # find interesting fields hflux_fields = [f for f in herschel[1].columns.names if (('pacs' in f) or ('spire' in f)) and f[-3:] != 'unc'] hunc_fields = [f for f in herschel[1].columns.names if (('pacs' in f) or ('spire' in f)) and f[-3:] == 'unc'] # different versions if objname is passed or no if objname is not None: match = herschel[1].data['Name'] == objname.lower().replace(' ','') hflux = np.array([np.squeeze(herschel[1].data[match][hflux_fields[i]]) for i in xrange(len(hflux_fields))]) hunc = np.array([np.squeeze(herschel[1].data[match][f]) for f in hunc_fields]) else: optnames = hdulist[1].data['Name'] hnames = herschel[1].data['Name'] # non-pythonic, i know, but why change if it works? hflux,hunc = np.zeros(shape=(len(hflux_fields),len(hnames))), np.zeros(shape=(len(hflux_fields),len(hnames))) for ii in xrange(len(optnames)): match = hnames == optnames[ii].lower().replace(' ','') for kk in xrange(len(hflux_fields)): hflux[kk,ii] = herschel[1].data[match][hflux_fields[kk]] hunc[kk,ii] = herschel[1].data[match][hunc_fields[kk]] #### combine with brown catalog # convert from Jy to maggies flux = np.concatenate((flux,hflux/3631.)) unc = np.concatenate((unc, hunc/3631.)) mag_fields = np.append(mag_fields,hflux_fields) # phot mask phot_mask_brown = mag != 0 phot_mask_hersch = hflux != 0 phot_mask = np.concatenate((phot_mask_brown,phot_mask_hersch)) # map brown filters to FSPS filters # and remove fields where we don't have filter definitions filters,fsps_filters = translate_filters(mag_fields) have_definition = np.array(filters) != 'nan' filters = filters[have_definition] fsps_filters = fsps_filters[have_definition] flux = flux[have_definition] unc = unc[have_definition] phot_mask = phot_mask[have_definition] # load wave_effective from translate_filter import calc_lameff_for_fsps wave_effective = calc_lameff_for_fsps(filters) # error floors # split at 4.2 micron observed frame #high = wave_effective > 4.2e4 #low = wave_effective <= 4.2e4 #if high[0] != -1: # unc[high] = np.clip(unc[high], flux[high]*0.08, np.inf) #if low[0] != -1: # unc[low] = np.clip(unc[low], flux[low]*0.02, np.inf) unc = np.clip(unc, flux*0.05, np.inf) # build output dictionary obs['wave_effective'] = wave_effective obs['filters'] = observate.load_filters(fsps_filters) obs['phot_mask'] = phot_mask obs['maggies'] = flux obs['maggies_unc'] = unc obs['wavelength'] = None obs['spectrum'] = None obs['logify_spectrum'] = False if objname is None: obs['hnames'] = herschel[1].data['Name'] obs['names'] = hdulist[1].data['Name'] # tidy up hdulist.close() extinct.close() herschel.close() return obs
#Example hrdspy usage. determine dispersion in integrated spectrum #as a function of wavelength for a given mass and age. import matplotlib.pyplot as pl import time, pickle import numpy as np import starmodel, isochrone, cluster, imf from sedpy import observate, attenuation # choose a few filters and load them filterlist = observate.load_filters(['bessell_B','bessell_R']) # instantiate and load the isochrones and spectra first so you # don't have to do it for each cluster realization isoc = isochrone.Padova2007() isoc.load_all_isoc() speclib = starmodel.BaSeL3() speclib.read_all_Z() IMF = imf.SalpeterIMF(mlo=[0.1], mhi=[100.], alpha=[2.35]) A_v = 0.0 wave = speclib.wavelength nw = wave.shape[0] hdrtxt = ("A list of [header, wave, spectrum, stellar_masses] for {0} realizations " "of a cluster with M_*={1} M_sun of stars drawn from a Salpeter IMF (0.1, 100) " "at logt={2} yrs and metallicity Z={3} with A_v={4}. Spectrum is " "a {0} x {5} array while stellar masses is a {0} element list of lists, " "where each sublist gives the stellar masses above {6} M_sun for one realization.") nametemplate = "stochastic_lib/salp_stoch{0}_logM{1:3.1f}_logt{2:4.2f}.p"