def test_pdwrire_cols(tmpdir): """Test writer that can take variable column numbers.""" tmpfile = tmpdir.join("pd_multicol_test.dat") pd_multicol_name = str(tmpfile) data1 = range(5) data2 = range(5, 10) # 0 means successful write assert 0 == io.pdwrite_cols(pd_multicol_name, data1, data2, data1) assert 0 == io.pdwrite_cols(pd_multicol_name, data1) assert 0 == io.pdwrite_cols( pd_multicol_name, data1, data2, data1, data2, header=["headers", "for", "column", "labels"], ) assert 0 == io.pdwrite_cols(pd_multicol_name, data1, data2, sep=",", index=True) # clean-up utils.silent_remove(pd_multicol_name)
def test_write_col_errors_bad_keyword(tmpdir): tmpfile = tmpdir.join("pd_multicol_test.dat") pd_multicol_name = str(tmpfile) data1 = range(5) with pytest.raises(TypeError): io.pdwrite_cols(pd_multicol_name, data1, bad="keyword")
def test_write_col_errors_different_length(tmpdir): tmpfile = tmpdir.join("pd_multicol_test.dat") pd_multicol_name = str(tmpfile) data1 = range(5) data2 = range(5, 10) bad_data = range(6) # Different length # test uneven data lengths with pytest.raises(ValueError): io.pdwrite_cols(pd_multicol_name, data1, data2, bad_data)
def test_write_col_errors(tmpdir): tmpfile = tmpdir.join("pd_multicol_test.dat") pd_multicol_name = str(tmpfile) data1 = range(5) data2 = range(5, 10) bad_data = range(6) # Different length # test bad header with pytest.raises(ValueError): io.pdwrite_cols(pd_multicol_name, data1, data2, bad_data, header=["too", "many", "values"])
def to_file(self, fname: str, header: Optional[List[str]] = None, fmt: str = "%11.8f"): """Save the atmospheric model to a txt file. Converts micron back into nanometers to be consistent with from_file(). Parameters ---------- fname: str Name of atmosphere file to save to. header: Header lines to add. fmt: str String formatting """ if header is None: header = ["# atm_wav(nm)", "atm_flux", "atm_std_flux", "atm_mask"] return io.pdwrite_cols( fname, self.wl * 1000, self.transmission, self.std, self.mask.astype(int), header=header, float_format=fmt, )
def test_pdwrire_cols(): """Test writer that can take variable column numbers.""" filedir = "data/test_data" pd_multicol_name = os.path.join(filedir, "pd_multicol_test.dat") data1 = range(5) data2 = range(5, 10) bad_data = range(6) # Different length # 0 means successful write assert 0 == io.pdwrite_cols(pd_multicol_name, data1, data2, data1) assert 0 == io.pdwrite_cols(pd_multicol_name, data1) assert 0 == io.pdwrite_cols( pd_multicol_name, data1, data2, data1, data2, header=["headers", "for", "column", "labels"], ) assert 0 == io.pdwrite_cols(pd_multicol_name, data1, data2, sep=",", index=True) # test uneven data lengths with pytest.raises(ValueError): io.pdwrite_cols(pd_multicol_name, data1, data2, bad_data) # test bad header with pytest.raises(ValueError): io.pdwrite_cols(pd_multicol_name, data1, data2, bad_data, header=["too", "many", "values"]) with pytest.raises(TypeError): io.pdwrite_cols(pd_multicol_name, data1, bad="keyword") # clean-up utils.silent_remove(pd_multicol_name)
def main(bands="J", use_unshifted=False, save=False, snr=100, ref_band="J"): """Main function that calls calc_precision. Parameters ---------- bands: str or list of str or None, Default="J" Band letters to use. None does the bands Z through K. use_unshifted: bool default=False Flag to start with the un-Doppler shifted atmmodel. save: bool Save results to file. """ os.makedirs(eniric.paths["precision"], exist_ok=True) spectral_types = ["M0", "M3", "M6", "M9"] if "ALL" in bands: bands = ["Z", "Y", "J", "H", "K"] elif isinstance(bands, str): bands = [bands] vsini = ["1.0", "5.0", "10.0"] resolution = ["60k", "80k", "100k"] sampling = ["3"] results = calculate_prec( spectral_types, bands, vsini, resolution, sampling, plot_atm=False, plot_ste=False, plot_flux=False, paper_plots=False, rv_offset=0.0, use_unshifted=use_unshifted, snr=snr, ref_band=ref_band, ) print("{Combination\t\tPrec_1\t\tPrec_2\t\tPrec_3") print("-" * 20) for key in results: print( "{0:s}\t\t{1:0.4f}\t{2:0.4f}\t{3:0.4f}".format( key, results[key][0], results[key][1], results[key][2] ) ) # Save precision results if save: output_filename = os.path.join( eniric.paths["precision"], "precision_results_2017_ref_band-{0}_snr-{1}.dat".format(ref_band, snr), ) ids = [] prec_1s = [] prec_2s = [] prec_3s = [] for star in spectral_types: for band in bands: for vel in vsini: for res in resolution: id_string = "{0:s}-{1:s}-{2:.1f}-{3:s}".format( star, band, float(vel), res ) ids.append(id_string) prec_1s.append(results[id_string][0].value) prec_2s.append(results[id_string][1].value) prec_3s.append(results[id_string][2].value) io.pdwrite_cols( output_filename, ids, prec_1s, prec_2s, prec_3s, header=["# id", r"prec_1 [m/s]", r"prec_2 [m/s]", r"prec_3 [m/s]"], float_format="%5.01f", ) print("saved results to {}".format(output_filename))
def main( startype, temp, logg, metallicity, alpha, flux_type="photon", data_dir=None, phoenix_dir=None, replace=False, ): """Prepare datafiles for phoenix models that match the input parameters. This add the wavelength information to each spectra and converts to microns/photons if the flux_type="photons" is given. We do realise that this is a waste of space and it would be more storage efficient to just read in the phoenix raw fits files and wavelength file when needed. """ if data_dir is None: data_dir = eniric.paths["phoenix_dat"] os.makedirs(data_dir, exist_ok=True) if phoenix_dir is None: phoenix_dir = eniric.paths["phoenix_raw"] # Get Phoenix wavelength data wavelength_file = "WAVE_PHOENIX-ACES-AGSS-COND-2011.fits" wavelength = fits.getdata(os.path.join(phoenix_dir, wavelength_file)) if flux_type == "photon": file_suffix = "_wave_photon.dat" # For saving output else: file_suffix = "_wave.dat" # Convert Stellar_types into stellar_dict = {"M0": 3900.0, "M3": 3500.0, "M6": 2800.0, "M9": 2600.0} # Add temperature of stellar_type to temp list for star in startype: try: temp.append(stellar_dict[star]) except KeyError: print( "Stellar type {0} is not implemented here (yet), submit and issue." .format(star)) # Get all phoenix fits files we want to convert for (path, dirs, files) in os.walk(phoenix_dir): phoenix_files = [] for f in files: # Test if filename meets conditions end_cond = f.endswith("PHOENIX-ACES-AGSS-COND-2011-HiRes.fits") try: if "Alpha=" in f: ( match_temp, match_logg, match_feh, match_alpha ) = re.search( r"(\d{5})-(\d\.\d\d)([+\-]\d\.\d)\.Alpha=([+\-]\d\.\d\d)\.", f).groups() alpha_cond = float(match_alpha) in alpha else: (match_temp, match_logg, match_feh) = re.search(r"(\d{5})-(\d\.\d\d)([+\-]\d\.\d)", f).groups() alpha_cond = True # To make work except AttributeError: # This file doesn't match what we want so continue with next loop continue temp_cond = float(match_temp) in temp feh_cond = float(match_feh) in metallicity logg_cond = float(match_logg) in logg if np.all([end_cond, temp_cond, feh_cond, logg_cond, alpha_cond]): # All conditions met # Matching file found phoenix_files.append(f) else: pass for phoenix_file in phoenix_files: z_folder = path.split(os.sep)[-1] os.makedirs(os.path.join(data_dir, z_folder), exist_ok=True) output_filename = os.path.join(data_dir, z_folder, phoenix_file[:-5] + file_suffix) # Name of .dat file if os.path.exists(output_filename) and not replace: print("Skipping as {0} already exists (use -r to replace)". format(output_filename)) continue spectra = fits.getdata(os.path.join(path, phoenix_file)) # Need to add conversions pedro preformed to flux! """The energy units of Phoenix fits files is erg/s/cm**2/cm We transform the flux into photons in the read_spectrum() function by multiplying the flux result by the wavelength (lambda) Flux_photon = Flux_energy/Energy_photon with Energy_photon = h*c/lambda Flux_photon = Flux_energy * lambda / (h * c) Here we convert the flux into erg/s/cm**2/\mum by multiplying by 10**-4 cm/\mum Flux_e(erg/s/cm**2/\mum) = Flux_e(erg/s/cm**2/cm) * (1 cm) / (10000 \mum) """ spectra_micron = spectra * 10**-4 # Convert /cm to /micron if flux_type == "photon": wavelength_micron = (wavelength * 10**-4 ) # Convert Angstrom to micron spectra_photon = ( spectra_micron * wavelength_micron ) # Ignoring constants h*c in photon energy equation result = io.pdwrite_cols( output_filename, wavelength_micron, spectra_photon, header=["# Wavelength (micron)", r"Flux (photon/s/cm^2)"], float_format="%.7f", ) else: result = io.pdwrite_cols( output_filename, wavelength, spectra_micron, header=[ "# Wavelength (Angstrom)", r"Flux (erg/s/cm^2/micron)" ], float_format=None, ) if not result: print("Successfully wrote to ", output_filename) else: print("Failed to write to ", output_filename) print("Done") return 0