def test_make_extinguished_sed_grid():
# download the needed files
priors_fname = download_rename("beast_example_phat_spec_w_priors.grid.hd5")
filter_fname = download_rename("filters.hd5")
# download cached version of sed grid
seds_fname_cache = download_rename("beast_example_phat_seds.grid.hd5")
################
# generate the same extinguished SED grid from the code
# Add in the filters
filters = [
"HST_WFC3_F275W",
"HST_WFC3_F336W",
"HST_ACS_WFC_F475W",
"HST_ACS_WFC_F814W",
"HST_WFC3_F110W",
"HST_WFC3_F160W",
]
add_spectral_properties_kwargs = dict(filternames=filters)
g_pspec = grid.FileSpectralGrid(priors_fname, backend="memory")
# generate the SED grid by integrating the filter response functions
# effect of dust extinction applied before filter integration
# also computes the dust priors as weights
seds_fname = "/tmp/beast_example_phat_sed.grid.hd5"
seds_fname, g_seds = make_extinguished_sed_grid(
"test",
g_pspec,
filters,
seds_fname=seds_fname,
filterLib=filter_fname,
extLaw=extinction.Gordon16_RvFALaw(),
av=[0.0, 10.055, 1.0],
rv=[2.0, 6.0, 1.0],
fA=[0.0, 1.0, 0.25],
av_prior_model={"name": "flat"},
rv_prior_model={"name": "flat"},
fA_prior_model={"name": "flat"},
add_spectral_properties_kwargs=add_spectral_properties_kwargs,
)
# compare the new to the cached version
compare_hdf5(seds_fname_cache, seds_fname)
def test_add_stellar_priors_to_spectral_grid():
# download the needed files
gspec_fname = download_rename("beast_example_phat_spec_grid.hd5")
# download cached version of spectral grid with priors
priors_fname_cache = download_rename("beast_example_phat_spec_w_priors.grid.hd5")
###############
# generate the spectral grid with stellar priors from the code
gspec_fname = "/tmp/beast_example_phat_spec_grid.hd5"
specgrid = grid.FileSpectralGrid(gspec_fname, backend="memory")
priors_fname = "/tmp/beast_example_phat_spec_w_priors.grid.hd5"
priors_fname, g = add_stellar_priors("test", specgrid, priors_fname=priors_fname)
# compare the new to the cached version
compare_hdf5(priors_fname_cache, priors_fname)
def make_spectral_grid(
project,
oiso,
osl=None,
bounds={},
verbose=True,
spec_fname=None,
distance=10,
distance_unit=units.pc,
redshift=0.0,
filterLib=None,
add_spectral_properties_kwargs=None,
extLaw=None,
**kwargs
):
"""
The spectral grid is generated using the stellar parameters by
interpolation of the isochrones and the generation of spectra into the
physical units
Parameters
----------
project: str
project name
oiso: isochrone.Isochrone object
set of isochrones to use
osl: stellib.Stellib object
Spectral library to use (default stellib.Kurucz)
distance: float or list of float
distances at which models should be shifted, specified as a
single number or as [min, max, step]
0 means absolute magnitude.
distance_unit: astropy length unit or mag
distances will be evenly spaced in this unit
therefore, specifying a distance grid in mag units will lead to
a log grid
redshift: float
Redshift to which wavelengths should be shifted
Default is 0 (rest frame)
spec_fname: str
full filename to save the spectral grid into
filterLib: str
full filename to the filter library hd5 file
extLaw: extinction.ExtLaw (default=None)
if set, only save the spectrum for the wavelengths over which the
extinction law is valid
add_spectral_properties_kwargs: dict
keyword arguments to call :func:`add_spectral_properties`
to add model properties from the spectra into the grid property table
Returns
-------
fname: str
name of saved file
g: grid.SpectralGrid object
spectral grid to transform
"""
if spec_fname is None:
spec_fname = "%s/%s_spec_grid.hd5" % (project, project)
if not os.path.isfile(spec_fname):
osl = osl or stellib.Kurucz()
# filter extrapolations of the grid with given sensitivities in
# logg and logT
if "dlogT" not in bounds:
bounds["dlogT"] = 0.1
if "dlogg" not in bounds:
bounds["dlogg"] = 0.3
# make the spectral grid
if verbose:
print("Make spectra")
g = creategrid.gen_spectral_grid_from_stellib_given_points(
osl, oiso.data, bounds=bounds
)
# Construct the distances array. Turn single value into
# 1-element list if single distance is given.
_distance = np.atleast_1d(distance)
if len(_distance) == 3:
mindist, maxdist, stepdist = _distance
distances = np.arange(mindist, maxdist + stepdist, stepdist)
elif len(_distance) == 1:
distances = np.array(_distance)
else:
raise ValueError("distance needs to be (min, max, step) or single number")
# calculate the distances in pc
if distance_unit == units.mag:
distances = np.power(10, distances / 5.0 + 1) * units.pc
else:
distances = (distances * distance_unit).to(units.pc)
print("applying {} distances".format(len(distances)))
if verbose:
print(
"Adding spectral properties:",
add_spectral_properties_kwargs is not None,
)
if add_spectral_properties_kwargs is not None:
nameformat = (
add_spectral_properties_kwargs.pop("nameformat", "{0:s}") + "_nd"
)
# Apply the distances to the stars. Seds already at 10 pc, need
# multiplication by the square of the ratio to this distance.
# TODO: Applying the distances might have to happen in chunks
# for larger grids.
def apply_distance_and_spectral_props(g):
# distance
g = creategrid.apply_distance_grid(g, distances, redshift=redshift)
# spectral props
if add_spectral_properties_kwargs is not None:
g = creategrid.add_spectral_properties(
g,
nameformat=nameformat,
filterLib=filterLib,
**add_spectral_properties_kwargs
)
# extinction
if extLaw is not None:
ext_law_range_A = 1e4 / np.array(extLaw.x_range)
valid_lambda = np.where(
(g.lamb > np.min(ext_law_range_A))
& (g.lamb < np.max(ext_law_range_A))
)[0]
g.lamb = g.lamb[valid_lambda]
g.seds = g.seds[:, valid_lambda]
return g
# if extLaw is set, remove wavelengths where the extinction curve
# isn't valid
# Perform the extensions defined above and Write to disk
if hasattr(g, "writeHDF"):
g = apply_distance_and_spectral_props(g)
g.writeHDF(spec_fname)
else:
for gk in g:
gk = apply_distance_and_spectral_props(gk)
gk.writeHDF(spec_fname, append=True)
g = grid.FileSpectralGrid(spec_fname, backend="memory")
return (spec_fname, g)
def add_stellar_priors(project, specgrid,
age_prior_model={'name': 'flat'},
mass_prior_model={'name': 'kroupa'},
met_prior_model={'name': 'flat'},
verbose=True,
priors_fname=None,
**kwargs):
"""
make_priors -- compute the weights for the stellar priors
Parameters
----------
project: str
project name
specgrid: grid.SpectralGrid object
spectral grid to transform
age_prior_model: dict
dict including prior model name and parameters
mass_prior_model: dict
dict including prior model name and parameters
met_prior_model: dict
dict including prior model name and parameters
priors_fname: str
full filename to which to save the spectral grid with priors
Returns
-------
fname: str
name of saved file
g: grid.SpectralGrid object
spectral grid to transform
"""
if priors_fname is None:
priors_fname = "%s/%s_spec_w_priors.grid.hd5" % (project, project)
if not os.path.isfile(priors_fname):
if verbose:
print("Make Prior Weights")
compute_age_mass_metallicity_weights(
specgrid.grid,
age_prior_model=age_prior_model,
mass_prior_model=mass_prior_model,
met_prior_model=met_prior_model,
**kwargs)
# write to disk
if hasattr(specgrid, "writeHDF"):
specgrid.writeHDF(priors_fname)
else:
for gk in specgrid:
gk.writeHDF(priors_fname, append=True)
g = grid.FileSpectralGrid(priors_fname, backend="memory")
return (priors_fname, g)