def test_star_type_probability_all_params(): """ Test for star_type_probability.py """ # download the needed files pdf1d_fname = download_rename("beast_example_phat_pdf1d.fits") pdf2d_fname = download_rename("beast_example_phat_pdf2d.fits") star_prob_fname = download_rename("beast_example_phat_startype.fits") # run star_type_probability star_prob = star_type_probability.star_type_probability( pdf1d_fname, pdf2d_fname, output_filebase=None, ext_O_star_params={ 'min_M_ini': 10, 'min_Av': 0.5, 'max_Av': 5 }) # expected output table expected_star_prob = Table.read(star_prob_fname) # compare to new table compare_tables(expected_star_prob, Table(star_prob))
def test_star_type_probability_no_Av(self): """ Test for star_type_probability.py """ # download the needed files pdf2d_fname = download_rename("beast_example_phat_pdf2d_no_Av.fits") star_prob_fname = download_rename( "beast_example_phat_startype_no_Av.fits") # run star_type_probability star_prob = star_type_probability.star_type_probability( self.pdf1d_fname_cache, pdf2d_fname, output_filebase=None, ext_O_star_params={ "min_M_ini": 10, "min_Av": 0.5, "max_Av": 5 }, ) # expected output table expected_star_prob = Table.read(star_prob_fname) # compare to new table compare_tables(expected_star_prob, Table(star_prob))
def test_padova_isochrone_download(): # download the cached version iso_fname_cache = download_rename("beast_example_phat_iso.csv") # download the file live from the website savename = "/tmp/padova_iso.csv" iso_fname, oiso = make_iso_table( "test", iso_fname=savename, logtmin=6.0, logtmax=10.13, dlogt=1.0, z=[0.03, 0.019, 0.008, 0.004], ) # read the cached and new tables using astropy tables table_cache = Table.read(iso_fname_cache, format="ascii.csv", comment="#", delimiter=",") table_new = Table.read(iso_fname, format="ascii.csv", comment="#", delimiter=",") # compare compare_tables(table_cache, table_new)
def test_padova_isochrone_download(self): """ Generate the padova isochrone table and compare the result to a cached version. """ # download the file live from the website savename = tempfile.NamedTemporaryFile(suffix=".csv").name infoname = tempfile.NamedTemporaryFile(suffix=".asdf").name (iso_fname, g) = make_iso_table( "test", iso_fname=savename, logtmin=self.settings.logt[0], logtmax=self.settings.logt[1], dlogt=self.settings.logt[2], z=self.settings.z, info_fname=infoname, ) # read the cached and new tables using astropy tables table_cache = Table.read(self.iso_fname_cache, format="ascii.csv", comment="#", delimiter=",") table_new = Table.read(iso_fname, format="ascii.csv", comment="#", delimiter=",") # compare compare_tables(table_cache, table_new)
def test_simobs(self): """ Simulate observations using cached versions of the sed grid and noise model and compare the result to a cached version. """ # download files specific to this test simobs_fname_cache = download_rename("beast_example_phat_simobs.fits") # get the physics model grid - includes priors modelsedgrid = SEDGrid(self.seds_fname_cache) # read in the noise model - includes bias, unc, and completeness noisegrid = noisemodel.get_noisemodelcat(self.noise_fname_cache) table_new = gen_SimObs_from_sedgrid( modelsedgrid, noisegrid, nsim=100, compl_filter="max", ranseed=1234, ) # check that the simobs files are exactly the same table_cache = Table.read(simobs_fname_cache) # to avoid issues with uppercase vs lowercase column names, make them all # the same before comparing for col in table_new.colnames: table_new[col].name = col.upper() for col in table_cache.colnames: table_cache[col].name = col.upper() compare_tables(table_cache, table_new)
def test_ast_pick_models(self): """ Generate the artifial star test (AST) inputs using a cached version of the sed grid and compare the result to a cached version. """ # download files specific to this test cached_table_filename = download_rename( "phat_small/cache_inputAST.txt") mag_cuts = [1.0] seds_fname = self.seds_fname_cache if self.dset != "phat": seds_fname = download_rename( "phat_small/beast_example_phat_seds.grid.hd5") else: seds_fname = self.seds_fname_cache outname = tempfile.NamedTemporaryFile(suffix=".txt").name make_ast_input_list.pick_models( seds_fname, self.settings.filters, mag_cuts, outfile=outname, ranseed=1234, ) table_new = Table.read(outname, format="ascii") # download cached version of the file and compare it to new file table_cache = Table.read(cached_table_filename, format="csv", delimiter=" ") compare_tables(table_new, table_cache)
def test_compare_spec_type_inFOV(self): """ Test for compare_spec_type. Inputs and expected outputs created by running generate_files_for_tests.py in beast-examples/metal_small. In this version, the stars are in the imaging field of view. """ # download cached file compare_spec_type_fname = download_rename( f"{self.basename}_compare_spec_type.asdf") with asdf.open(compare_spec_type_fname) as af: compare_spec_type_info = copy.deepcopy(af.tree) # run compare_spec_type spec_type = compare_spec_type( self.obs_fname_cache, self.stats_fname_cache, **compare_spec_type_info["input"], ) # expected output table expected_table = Table(compare_spec_type_info["output"]) # compare to new table compare_tables(expected_table, Table(spec_type), rtol=2e-3)
def test_star_type_probability_all_params(self): """ Test for star_type_probability. Inputs and expected outputs created by running generate_files_for_tests.py in beast-examples/metal_small. In this version, all required parameters are present. """ # download cached file star_prob_fname = download_rename( f"{self.basename}_star_type_probability.asdf") with asdf.open(star_prob_fname) as af: star_prob_info = copy.deepcopy(af.tree) # run star_type_probability star_prob = star_type_probability.star_type_probability( self.pdf1d_fname_cache, self.pdf2d_fname_cache, **star_prob_info["input"], ) # expected output table expected_star_prob = Table(star_prob_info["output"]) # compare to new table compare_tables(expected_star_prob, Table(star_prob))
def test_create_physicsmodel_no_subgrid(self): """ Test create_physicsmodel.py, assuming no subgrids """ # run create_physicsmodel create_physicsmodel.create_physicsmodel(self.settings, nsubs=self.settings.n_subgrid, nprocs=1) # check that files match # - isochrones table_cache = Table.read( self.iso_fname_cache, format="ascii.csv", comment="#", delimiter=",", ) table_new = Table.read( f"./{self.settings.project}/{self.settings.project}_iso.csv", format="ascii.csv", comment="#", delimiter=",", ) compare_tables(table_cache, table_new) # - spectra with priors compare_hdf5( self.priors_fname_cache, f"./{self.settings.project}/{self.settings.project}_spec_w_priors.grid.hd5", ) # - SEDs grid compare_hdf5( self.seds_fname_cache, f"./{self.settings.project}/{self.settings.project}_seds.grid.hd5", )
def test_pick_models(): # download the needed files vega_fname = download_rename("vega.hd5") filename = download_rename("beast_example_phat_seds.grid.hd5") filters = [ "HST_WFC3_F275W", "HST_WFC3_F336W", "HST_ACS_WFC_F475W", "HST_ACS_WFC_F814W", "HST_WFC3_F110W", "HST_WFC3_F160W", ] mag_cuts = [1.0] make_ast_input_list.pick_models( filename, filters, mag_cuts, vega_fname=vega_fname, outfile="/tmp/test_inputAST.txt", ranseed=1234, ) table_new = Table.read("/tmp/test_inputAST.txt", format="ascii") # download cached version of the file and compare it to new file cached_table_filename = download_rename("cache_inputAST.txt") table_cache = Table.read(cached_table_filename, format="csv", delimiter=" ") compare_tables(table_new, table_cache)
def test_trim_grid(): # download the needed files vega_fname = download_rename('vega.hd5') seds_fname = download_rename('beast_example_phat_seds.grid.hd5') noise_fname = download_rename('beast_example_phat_noisemodel.hd5') # download cached version of noisemodel on the sed grid simobs_fname_cache = download_rename('beast_example_phat_simobs.fits') ################ # get the physics model grid - includes priors modelsedgrid = FileSEDGrid(seds_fname) # read in the noise model - includes bias, unc, and completeness noisegrid = noisemodel.get_noisemodelcat(noise_fname) table_new = gen_SimObs_from_sedgrid(modelsedgrid, noisegrid, nsim=100, compl_filter="f475w", ranseed=1234, vega_fname=vega_fname) # check that the simobs files are exactly the same table_cache = Table.read(simobs_fname_cache) compare_tables(table_cache, table_new)
def test_create_physicsmodel_with_subgrid(self): """ Test create_physicsmodel.py, assuming two subgrids """ # run create_physicsmodel create_physicsmodel.create_physicsmodel( self.settings_sg, nsubs=self.settings_sg.n_subgrid, nprocs=1) # check that files match # - isochrones table_cache = Table.read( self.iso_fname_cache, format="ascii.csv", comment="#", delimiter=",", ) table_new = Table.read( "beast_metal_small_subgrids/beast_metal_small_subgrids_iso.csv", format="ascii.csv", comment="#", delimiter=",", ) compare_tables(table_cache, table_new) # - spectra with priors compare_hdf5( self.priors_fname_cache, "./beast_metal_small_subgrids/beast_metal_small_subgrids_spec_w_priors.grid.hd5", ) compare_hdf5( self.priors_sub0_fname_cache, "beast_metal_small_subgrids/beast_metal_small_subgrids_spec_w_priors.gridsub0.hd5", ) compare_hdf5( self.priors_sub1_fname_cache, "beast_metal_small_subgrids/beast_metal_small_subgrids_spec_w_priors.gridsub1.hd5", ) # - SEDs grid compare_hdf5( self.seds_sub0_fname_cache, "beast_metal_small_subgrids/beast_metal_small_subgrids_seds.gridsub0.hd5", ) compare_hdf5( self.seds_sub1_fname_cache, "beast_metal_small_subgrids/beast_metal_small_subgrids_seds.gridsub1.hd5", ) # - list of subgrids with open("./beast_metal_small_subgrids/subgrid_fnames.txt") as f: temp = f.read() subgrid_list = [x for x in temp.split("\n") if x != ""] expected_list = [ "beast_metal_small_subgrids/beast_metal_small_subgrids_seds.gridsub0.hd5", "beast_metal_small_subgrids/beast_metal_small_subgrids_seds.gridsub1.hd5", ] assert subgrid_list == expected_list, "subgrid_fnames.txt has incorrect content"
def test_fit_grid(): # download the needed files vega_fname = download_rename('vega.hd5') obs_fname = download_rename('b15_4band_det_27_A.fits') noise_trim_fname = download_rename( 'beast_example_phat_noisemodel_trim.grid.hd5') seds_trim_fname = download_rename('beast_example_phat_seds_trim.grid.hd5') # download cached version of fitting results stats_fname_cache = download_rename('beast_example_phat_stats.fits') pdf1d_fname_cache = download_rename('beast_example_phat_pdf1d.fits') ################ # read in the the AST noise model noisemodel_vals = noisemodel.get_noisemodelcat(noise_trim_fname) # read in the observed data filters = [ 'HST_WFC3_F275W', 'HST_WFC3_F336W', 'HST_ACS_WFC_F475W', 'HST_ACS_WFC_F814W', 'HST_WFC3_F110W', 'HST_WFC3_F160W' ] basefilters = ['F275W', 'F336W', 'F475W', 'F814W', 'F110W', 'F160W'] obs_colnames = [f.lower() + '_rate' for f in basefilters] obsdata = get_obscat(obs_fname, filters, obs_colnames, vega_fname=vega_fname) # output files stats_fname = '/tmp/beast_example_phat_stats.fits' pdf1d_fname = '/tmp/beast_example_phat_pdf1d.fits' lnp_fname = '/tmp/beast_example_phat_lnp.hd5' fit.summary_table_memory(obsdata, noisemodel_vals, seds_trim_fname, threshold=-10., save_every_npts=100, lnp_npts=60, stats_outname=stats_fname, pdf1d_outname=pdf1d_fname, lnp_outname=lnp_fname) # check that the stats files are exactly the same table_cache = Table.read(stats_fname_cache) table_new = Table.read(stats_fname) compare_tables(table_cache, table_new) # lnp files not checked as they are randomly sparsely sampled # hence will be different every time the fitting is run # check that the pdf1d files are exactly the same compare_fits(pdf1d_fname_cache, pdf1d_fname)
def test_convert_hd5_to_fits(): # Pick some random .hd5 file to convert data_fname = download_rename("M31-B09-EAST_tinychunk.phot.hdf5") data_fname_cache = download_rename("M31-B09-EAST_tinychunk.st.fits") # Convert the file st_file(data_fname) # Compare the contents of the new file to the cached version data = Table(fits.getdata(data_fname.replace("phot.hdf5", "st.fits"))) data_cache = Table(fits.getdata(data_fname_cache)) compare_tables(data_cache, data)
def test_fit_grid(self): """ Fit a cached version of the observations with cached version of the trimmed sed grid and noisemodel and compare the result to cached versions of the stats and pdf1d files. """ # read in the the AST noise model noisemodel_vals = noisemodel.get_noisemodelcat( self.noise_trim_fname_cache) # read in the observed data obsdata = Observations(self.obs_fname_cache, self.settings.filters, self.settings.obs_colnames) # output files stats_fname = tempfile.NamedTemporaryFile(suffix=".fits").name pdf1d_fname = tempfile.NamedTemporaryFile(suffix=".fits").name pdf2d_fname = tempfile.NamedTemporaryFile(suffix=".fits").name lnp_fname = tempfile.NamedTemporaryFile(suffix=".hd5").name fit.summary_table_memory( obsdata, noisemodel_vals, self.seds_trim_fname_cache, threshold=-10.0, save_every_npts=100, lnp_npts=500, max_nbins=200, stats_outname=stats_fname, pdf1d_outname=pdf1d_fname, pdf2d_outname=pdf2d_fname, pdf2d_param_list=["Av", "M_ini", "logT"], lnp_outname=lnp_fname, surveyname=self.settings.surveyname, ) # check that the stats files are exactly the same table_cache = Table.read(self.stats_fname_cache) table_new = Table.read(stats_fname) compare_tables(table_cache, table_new) # lnp files not checked as they are randomly sparsely sampled # hence will be different every time the fitting is run # check that the pdf1d/pdf2d files are exactly the same compare_fits(self.pdf1d_fname_cache, pdf1d_fname) compare_fits(self.pdf2d_fname_cache, pdf2d_fname)
def test_compare_spec_type_notFOV(): """ Test for compare_spec_type. The spectrally-typed stars aren't real sources, they're just invented for the purposes of documenting/testing the code. In this version, the stars are NOT in the imaging field of view. """ # download the needed files obs_fname = download_rename("b15_4band_det_27_A.fits") stats_fname = download_rename("beast_example_phat_stats.fits") # run compare_spec_type spec_type = compare_spec_type( obs_fname, stats_fname, [1.0], # RA [1.0], # Dec ['B'], # Spectral type [4], # Subtype ['V'], # Luminosity class match_radius=0.2 # Match radius (arcsec) ) # expected output table expected_table = Table({ 'spec_ra': [1.0], 'spec_dec': [1.0], 'spec_type': ['B 4 V'], 'spec_teff': [None], 'spec_logg': [None], 'phot_cat_ind': [None], 'stats_cat_ind': [None], 'beast_teff_p50': [None], 'beast_teff_p16': [None], 'beast_teff_p84': [None], 'beast_logg_p50': [None], 'beast_logg_p16': [None], 'beast_logg_p84': [None], 'teff_sigma': [None], 'logg_sigma': [None], }) # compare to new table compare_tables(expected_table, Table(spec_type))
def test_compare_spec_type_inFOV(): """ Test for compare_spec_type. The spectrally-typed stars aren't real sources, they're just invented for the purposes of documenting/testing the code. In this version, the stars are in the imaging field of view. """ # download the needed files obs_fname = download_rename("b15_4band_det_27_A.fits") stats_fname = download_rename("beast_example_phat_stats.fits") # run compare_spec_type spec_type = compare_spec_type( obs_fname, stats_fname, [11.2335881, 11.23342557], # RA [41.9001895, 41.90006316], # Dec ['A', 'G'], # Spectral type [2, 7], # Subtype ['II', 'II'], # Luminosity class match_radius=0.2 # Match radius (arcsec) ) # expected output table expected_table = Table({ 'spec_ra': [11.2335881, 11.23342557], 'spec_dec': [41.9001895, 41.90006316], 'spec_type': ['A 2 II', 'G 7 II'], 'spec_teff': [9000.0, 4916.666666666667], 'spec_logg': [2.7164474106543732, 1.7184474106543735], 'phot_cat_ind': [27, 8], 'stats_cat_ind': [27, 8], 'beast_teff_p50': [9046.250020338754, 4528.230977991138], 'beast_teff_p16': [8643.670633196869, 4335.617282355577], 'beast_teff_p84': [9536.391362054928, 4729.401710221546], 'beast_logg_p50': [2.714286917261312, 1.7684285714285717], 'beast_logg_p16': [2.636272525730954, 1.7014832653061227], 'beast_logg_p84': [2.799534708811963, 1.8353738775510207], 'teff_sigma': [-0.11488422362383206, 1.9308757510045778], 'logg_sigma': [0.025343687546173433, -0.7465969411324851] }) # compare to new table compare_tables(expected_table, Table(spec_type), rtol=2e-3)
def test_pick_models(): # download the needed files vega_fname = download_rename('vega.hd5') filename = download_rename('beast_example_phat_seds.grid.hd5') filters = ['HST_WFC3_F275W', 'HST_WFC3_F336W', 'HST_ACS_WFC_F475W', 'HST_ACS_WFC_F814W', 'HST_WFC3_F110W', 'HST_WFC3_F160W'] mag_cuts = [1.] table_out = make_ast_input_list.pick_models(filename, filters, mag_cuts, vega_fname=vega_fname, outfile='/tmp/test_inputAST.txt', ranseed=1234) table_new = Table.read('/tmp/test_inputAST.txt', format='ascii') # download cached version of the file and compare it to new file cached_table_filename = download_rename('cache_inputAST.txt') table_cache = Table.read(cached_table_filename, format='csv', delimiter=' ') compare_tables(table_new, table_cache)
def test_star_type_probability_no_Av(self): """ Test for star_type_probability. In this version, A_V was not saved in the 2D PDFs. """ # download cached file star_prob_fname = download_rename( f"{self.basename}_star_type_probability.asdf") with asdf.open(star_prob_fname) as af: star_prob_info = copy.deepcopy(af.tree) # edit the 2D PDF file to not have A_V info temp_pdf2d_fname = tempfile.NamedTemporaryFile(suffix=".fits").name temp_hdu_list = [] with fits.open(self.pdf2d_fname_cache) as hdu: for ext in hdu: if "Av+" in ext.name or "+Av" in ext.name: continue temp_hdu_list.append(ext) fits.HDUList(temp_hdu_list).writeto(temp_pdf2d_fname) # edit the expected output to have NaNs in columns that require A_V # (currently, that's all columns) expected_star_prob = Table(star_prob_info["output"]) for col in expected_star_prob.colnames: if col == "ext_O_star": expected_star_prob[col] = np.nan if col == "dusty_agb": expected_star_prob[col] = np.nan # run star_type_probability star_prob = star_type_probability.star_type_probability( self.pdf1d_fname_cache, temp_pdf2d_fname, **star_prob_info["input"], ) # compare to expected table compare_tables(expected_star_prob, Table(star_prob))
def test_compare_spec_type_notFOV(self): """ Test for compare_spec_type. In this version, the stars are NOT in the imaging field of view. """ # run compare_spec_type spec_type = compare_spec_type( self.obs_fname_cache, self.stats_fname_cache, [1.0], # RA [1.0], # Dec ["B"], # Spectral type [4], # Subtype ["V"], # Luminosity class match_radius=0.2, # Match radius (arcsec) ) # expected output table expected_table = Table( { "spec_ra": [1.0], "spec_dec": [1.0], "spec_type": ["B 4 V"], "spec_teff": [None], "spec_logg": [None], "phot_cat_ind": [None], "stats_cat_ind": [None], "beast_teff_p50": [None], "beast_teff_p16": [None], "beast_teff_p84": [None], "beast_logg_p50": [None], "beast_logg_p16": [None], "beast_logg_p84": [None], "teff_sigma": [None], "logg_sigma": [None], } ) # compare to new table compare_tables(expected_table, Table(spec_type))
def test_compare_spec_type_inFOV(self): """ Test for compare_spec_type. The spectrally-typed stars aren't real sources, they're just invented for the purposes of documenting/testing the code. In this version, the stars are in the imaging field of view. """ # run compare_spec_type spec_type = compare_spec_type( self.obs_fname_cache, self.stats_fname_cache, [11.2335881, 11.23342557], # RA [41.9001895, 41.90006316], # Dec ["A", "G"], # Spectral type [2, 7], # Subtype ["II", "II"], # Luminosity class match_radius=0.2, # Match radius (arcsec) ) # expected output table expected_table = Table({ "spec_ra": [11.2335881, 11.23342557], "spec_dec": [41.9001895, 41.90006316], "spec_type": ["A 2 II", "G 7 II"], "spec_teff": [9000.0, 4916.666666666667], "spec_logg": [2.7164474106543732, 1.7184474106543735], "phot_cat_ind": [27, 8], "stats_cat_ind": [27, 8], "beast_teff_p50": [9046.250020338754, 4528.230977991138], "beast_teff_p16": [8643.670633196869, 4335.617282355577], "beast_teff_p84": [9536.391362054928, 4729.401710221546], "beast_logg_p50": [2.714286917261312, 1.7684285714285717], "beast_logg_p16": [2.636272525730954, 1.7014832653061227], "beast_logg_p84": [2.799534708811963, 1.8353738775510207], "teff_sigma": [-0.11488422362383206, 1.9308757510045778], "logg_sigma": [0.025343687546173433, -0.7465969411324851], }) # compare to new table compare_tables(expected_table, Table(spec_type), rtol=2e-3)
def test_calc_depth_from_completeness(self): """ Test for calculate_depth.py """ # calculate depth for 50% and 75% completeness depth = calc_depth_from_completeness.calc_depth( self.seds_fname_cache, self.noise_fname_cache, completeness_value=[0.5, 0.75], vega_mag=True, ) # expected results expected_dict = { "HST_WFC3_F275W": [25.000309202589012, 24.80610510139205], "HST_WFC3_F336W": [24.65974845352875, 24.338061586936263], "HST_ACS_WFC_F475W": [np.nan, np.nan], "HST_ACS_WFC_F814W": [np.nan, 24.368742437736692], "HST_WFC3_F110W": [np.nan, np.nan], "HST_WFC3_F160W": [21.99298441116123, 21.504534701422067], } # compare them compare_tables(Table(expected_dict), Table(depth))
def test_simobs(): # download the needed files vega_fname = download_rename("vega.hd5") seds_fname = download_rename("beast_example_phat_seds.grid.hd5") noise_fname = download_rename("beast_example_phat_noisemodel.grid.hd5") # download cached version of noisemodel on the sed grid simobs_fname_cache = download_rename("beast_example_phat_simobs.fits") ################ # get the physics model grid - includes priors modelsedgrid = SEDGrid(seds_fname) # read in the noise model - includes bias, unc, and completeness noisegrid = noisemodel.get_noisemodelcat(noise_fname) table_new = gen_SimObs_from_sedgrid( modelsedgrid, noisegrid, nsim=100, compl_filter="f475w", ranseed=1234, vega_fname=vega_fname, ) # check that the simobs files are exactly the same table_cache = Table.read(simobs_fname_cache) # to avoid issues with uppercase vs lowercase column names, make them all # the same before comparing for col in table_new.colnames: table_new[col].name = col.upper() for col in table_cache.colnames: table_cache[col].name = col.upper() compare_tables(table_cache, table_new)
def test_sedgrid(cformat, cback, copygrid): """ Tests of the SEDGrid class """ n_bands = 3 filter_names = ["BAND1", "BAND2", "BAND3"] n_models = 100 lamb = [1.0, 2.0, 3.0] seds = np.zeros((n_models, n_bands)) cov_diag = np.full((n_models, n_bands), 0.1) n_offdiag = ((n_bands**2) - n_bands) // 2 cov_offdiag = np.full((n_models, n_offdiag), 1.0) cols = {"Av": [1.0, 1.1, 1.3], "Rv": [2.0, 3.0, 4.0]} header = {"Origin": "test_code"} gtable = Table(cols) gtable.meta = header tgrid = SEDGrid( lamb, seds=seds, grid=gtable, header=header, cov_diag=cov_diag, cov_offdiag=cov_offdiag, backend="memory", ) tgrid.header["filters"] = " ".join(filter_names) # check that the grid has the expected properties expected_props = [ "lamb", "seds", "cov_diag", "cov_offdiag", "grid", "nbytes", "filters", "header", "keys", ] for cprop in expected_props: assert hasattr(tgrid, cprop), f"missing {cprop} property" np.testing.assert_allclose(tgrid.lamb, lamb, err_msg="lambdas not equal") np.testing.assert_allclose(tgrid.seds, seds, err_msg="seds not equal") np.testing.assert_allclose(tgrid.cov_diag, cov_diag, err_msg="covdiag not equal") np.testing.assert_allclose(tgrid.cov_offdiag, cov_offdiag, err_msg="covoffdiag not equal") assert isinstance(tgrid.nbytes, (int, np.integer)), "grid nbytes property not integer" compare_tables(tgrid.grid, gtable) assert tgrid.grid.keys() == list(cols.keys()), "colnames of grid not equal" assert tgrid.filters == filter_names, "filters of grid not equal" # test writing and reading to disk print(f"testing {cformat} file format") tfile = NamedTemporaryFile(suffix=cformat) # write the file tgrid.write(tfile.name) # read in the file using different backends if (cback == "disk") and (cformat == ".fits"): # not supported return True print(f" testing {cback} backend") dgrid_in = SEDGrid(tfile.name, backend=cback) # test making a copy print(f" testing copygrid={copygrid}") if copygrid: dgrid = dgrid_in.copy() else: dgrid = dgrid_in print(dgrid) for cprop in expected_props: assert hasattr(dgrid, cprop), f"missing {cprop} property" # check that the grid has the expected values # this test is having a problem in the online travis ci # it someone manages to access another file with HST filter names! # no idea way. Works fine offline. # assert dgrid.filters == filter_names, "{cformat} file filters not equal" assert len(dgrid) == n_bands, f"{cformat} file len not equal" np.testing.assert_allclose( dgrid.lamb, lamb, err_msg=f"{cformat} file grid lambdas not equal") np.testing.assert_allclose(dgrid.seds, seds, err_msg=f"{cformat} file grid seds not equal") np.testing.assert_allclose( dgrid.cov_diag, cov_diag, err_msg=f"{cformat} file grid cov_diag not equal", ) np.testing.assert_allclose( dgrid.cov_offdiag, cov_offdiag, err_msg=f"{cformat} file grid cov_offdiag not equal", ) assert isinstance( dgrid.nbytes, (int, np.integer)), f"{cformat} file grid nbytes property not integer" dTable = dgrid.grid if (cback == "disk") and (cformat == ".hdf"): dTable = read_table_hdf5(dgrid.grid) compare_tables(dTable, gtable, otag=f"{cformat} file") assert dTable.keys() == list( cols.keys()), f"{cformat} file colnames of grid not equal" assert dgrid.keys() == tgrid.keys( ), f"{cformat} file colnames of grid not equal" # final copy - needed for disk backend to get the now defined variables print(dgrid) dgrid_fin = dgrid.copy() print(dgrid_fin)