def test_known_regression(self): # prevent regression of known bug self.assertEqual(mag_to_absmag(1., MAGIC_NUMBER), MAGIC_NUMBER) self.assertEqual(mag_to_absmag(MAGIC_NUMBER, MAGIC_NUMBER), MAGIC_NUMBER) self.assertEqual( np.all(mag_to_absmag(MAGIC_NUMBER, MAGIC_NUMBER, 1.) == (MAGIC_NUMBER, MAGIC_NUMBER)), True) self.assertEqual( np.all(mag_to_fakemag(MAGIC_NUMBER, MAGIC_NUMBER, 1.) == (MAGIC_NUMBER, MAGIC_NUMBER)), True) self.assertEqual(mag_to_fakemag(1., MAGIC_NUMBER), MAGIC_NUMBER) self.assertEqual(mag_to_fakemag(MAGIC_NUMBER, MAGIC_NUMBER), MAGIC_NUMBER) self.assertEqual(fakemag_to_pc(1., MAGIC_NUMBER).value, MAGIC_NUMBER) self.assertEqual(fakemag_to_pc(-1., 2.).value, MAGIC_NUMBER) self.assertEqual(absmag_to_pc(1., MAGIC_NUMBER).value, MAGIC_NUMBER)
def load_apogee_rc(dr=None, unit='distance', extinction=True): """ Load apogee red clumps (absolute magnitude measurement) :param dr: Apogee DR :type dr: int :param unit: which unit you want to get back - "absmag" for k-band absolute magnitude - "fakemag" for k-band fake magnitude - "distance" for distance in parsec :type unit: string :param extinction: Whether to take extinction into account, only affect when unit is NOT 'distance' :type extinction: bool :return: numpy array of ra, dec, array :rtype: ndarrays :History: | 2018-Jan-21 - Written - Henry Leung (University of Toronto) | 2018-May-12 - Updated - Henry Leung (University of Toronto) """ fullfilename = apogee_rc(dr=dr) with fits.open(fullfilename) as F: hdulist = F[1].data ra = hdulist['RA'] dec = hdulist['DEC'] rc_dist = hdulist['RC_DIST'] rc_parallax = (1 / rc_dist) * u.mas # Convert kpc to parallax in mas k_mag = hdulist['K'] if extinction: k_mag = extinction_correction(k_mag, hdulist['AK_TARG']) if unit == 'distance': output = rc_dist * 1000 elif unit == 'absmag': absmag = mag_to_absmag(k_mag, rc_parallax) output = absmag elif unit == 'fakemag': # fakemag requires parallax (mas) fakemag = mag_to_fakemag(k_mag, rc_parallax) output = fakemag else: raise ValueError('Unknown unit') return ra, dec, output
def load_apogee_distances(dr=None, metric='distance', cuts=True, extinction=False): """ Load apogee distances (absolute magnitude from stellar model) :param dr: Apogee DR :type dr: int :param metric: which metric you want ot get back - "absmag" for absolute magnitude - "fakemag" for fake magnitude - "distance" for distance :type metric: string :param cuts: Whether to cut bad data (negative parallax and percentage error more than 20%), or a float to set the threshold :type cuts: Union[boolean, float] :param extinction: Whether to take extinction into account :type extinction: bool :return: numpy array of ra, dec, metrics_array, metrics_err_array :rtype: ndarrays :History: 2018-Jan-25 - Written - Henry Leung (University of Toronto) """ fullfilename = apogee_distances(dr=dr) with fits.open(fullfilename) as F: hdulist = F[1].data # Convert kpc to pc distance = hdulist['BPG_dist50'] * 1000 dist_err = (hdulist['BPG_dist84'] - hdulist['BPG_dist16']) * 1000 allstarfullpath = allstar(dr=dr) with fits.open(allstarfullpath) as F: k_mag = F[1].data['K'] if extinction: k_mag = extinction_correction(k_mag, F[1].data['AK_TARG']) ra = F[1].data['RA'] dec = F[1].data['DEC'] # Bad index refers to nan index bad_index = np.argwhere(np.isnan(distance)) if metric == 'distance': # removed astropy units because of -9999. is dimensionless, will have issues output = distance output_err = dist_err elif metric == 'absmag': absmag, absmag_err = mag_to_absmag(k_mag, 1 / distance * u.arcsec, (1 / distance) * (dist_err / distance)) output = absmag output_err = absmag_err elif metric == 'fakemag': # fakemag requires parallax (mas) fakemag, fakemag_err = mag_to_fakemag(k_mag, 1000 / distance * u.mas, (1000 / distance) * (dist_err / distance)) output = fakemag output_err = fakemag_err else: raise ValueError('Unknown metric') # Set the nan index to -9999. as they are bad and unknown. Not magic_number as this is an APOGEE dataset output[bad_index], output_err[bad_index] = -9999., -9999. if cuts is False: pass else: distance[bad_index], dist_err[bad_index] = -9999., -9999. good_idx = [(dist_err / distance < (0.2 if cuts is True else cuts)) & (distance != -9999.)] ra = ra[good_idx] dec = dec[good_idx] output = output[good_idx] output_err = output_err[good_idx] return ra, dec, output, output_err
def test_astrometry_conversion(self): # Example data of [Vega, Sirius] absmag = np.array([0.582, 1.42]) mag = np.array([0.026, -1.46]) parallax = np.array([130.23, 379.21]) parallax_err = np.array([0.36, 1.58]) # Absmag related test pc = absmag_to_pc(absmag, mag) npt.assert_almost_equal(pc.value, 1000 / parallax, decimal=1) npt.assert_almost_equal(mag_to_absmag(mag, parallax * u.mas), absmag, decimal=1) self.assertEqual( np.any(absmag_to_fakemag(MAGIC_NUMBER) == MAGIC_NUMBER), True) absmag_test, absmag_err_test = mag_to_absmag(mag, parallax * u.mas, parallax_err) absmag_test_uniterr, absmag_err_test_uniterr = mag_to_absmag( mag, parallax * u.mas, parallax_err / 1000 * u.arcsec) absmag_test_arc, absmag_err_test_arc = mag_to_absmag( mag, parallax / 1000 * u.arcsec, parallax_err / 1000) absmag_test_unitless, absmag_err_test_unitless = mag_to_absmag( mag, parallax, parallax_err) # make sure unitless same as using astropy unit npt.assert_almost_equal(absmag_test, absmag_test_unitless) npt.assert_almost_equal(absmag_test, absmag_test_unitless) npt.assert_almost_equal(absmag_err_test, absmag_err_test_uniterr) # make sure astropy unit conversion works fine npt.assert_almost_equal(absmag_test, absmag_test_arc) npt.assert_almost_equal(absmag_err_test, absmag_err_test_arc) # =================== Fakemag related test ===================# # make sure these function did identity transform npt.assert_almost_equal(fakemag_to_absmag(absmag_to_fakemag(absmag)), absmag, decimal=1) # we can tests this after identity transformation confirmed npt.assert_almost_equal(fakemag_to_pc(absmag_to_fakemag(absmag), mag).value, 1000 / parallax, decimal=1) npt.assert_almost_equal(fakemag_to_pc( mag_to_fakemag(mag, parallax * u.mas), mag).value, 1000 / parallax, decimal=1) fakemag_test, fakemag_err_test = mag_to_fakemag( mag, parallax * u.mas, parallax_err) fakemag_test_uniterr, fakemag_err_test_uniterr = mag_to_fakemag( mag, parallax * u.mas, parallax_err / 1000 * u.arcsec) fakemag_test_unitless, fakemag_err_test_unitless = mag_to_fakemag( mag, parallax, parallax_err) fakemag_test_arc, fakemag_err_test_arc = mag_to_fakemag( mag, parallax / 1000 * u.arcsec, parallax_err / 1000) pc_result, pc_result_err = fakemag_to_pc(fakemag_test, mag, fakemag_err_test) pc_result_arc, pc_result_err_arc = fakemag_to_pc( fakemag_test_arc, mag, fakemag_err_test_arc) # Analytically solution checkung npt.assert_almost_equal(pc_result_err.value, (parallax_err / parallax) * pc.value, decimal=1) # make sure unitless same as using astropy unit npt.assert_almost_equal(fakemag_test, fakemag_test_unitless) npt.assert_almost_equal(fakemag_err_test, fakemag_err_test_uniterr) npt.assert_almost_equal(fakemag_err_test, fakemag_err_test_unitless) # make sure astropy unit conversion works fine npt.assert_almost_equal(fakemag_test, fakemag_test_arc) npt.assert_almost_equal(fakemag_err_test, fakemag_err_test_arc) npt.assert_almost_equal(pc_result.value, pc_result_arc.value) npt.assert_almost_equal(pc_result_err.value, pc_result_err_arc.value) # check gaia default dr dr = gaia_default_dr() self.assertEqual(dr, 1) dr = gaia_default_dr(dr=3) self.assertEqual(dr, 3)
def compile(self): h5name_check(self.filename) hdulist = self.load_allstar() indices = self.filter_apogeeid_list(hdulist) info = chips_pix_info(dr=self.apogee_dr) total_pix = (info[1] - info[0]) + (info[3] - info[2]) + (info[5] - info[4]) default_length = 900000 spec = np.zeros((default_length, total_pix), dtype=np.float32) spec_err = np.zeros((default_length, total_pix), dtype=np.float32) RA = np.zeros(default_length, dtype=np.float32) DEC = np.zeros(default_length, dtype=np.float32) SNR = np.zeros(default_length, dtype=np.float32) individual_flag = np.zeros(default_length, dtype=np.float32) Kmag = np.zeros(default_length, dtype=np.float32) AK_TARG = np.zeros(default_length, dtype=np.float32) # Data array teff = np.zeros(default_length, dtype=np.float32) logg = np.zeros(default_length, dtype=np.float32) MH = np.zeros(default_length, dtype=np.float32) alpha_M = np.zeros(default_length, dtype=np.float32) C = np.zeros(default_length, dtype=np.float32) C1 = np.zeros(default_length, dtype=np.float32) N = np.zeros(default_length, dtype=np.float32) O = np.zeros(default_length, dtype=np.float32) Na = np.zeros(default_length, dtype=np.float32) Mg = np.zeros(default_length, dtype=np.float32) Al = np.zeros(default_length, dtype=np.float32) Si = np.zeros(default_length, dtype=np.float32) P = np.zeros(default_length, dtype=np.float32) S = np.zeros(default_length, dtype=np.float32) K = np.zeros(default_length, dtype=np.float32) Ca = np.zeros(default_length, dtype=np.float32) Ti = np.zeros(default_length, dtype=np.float32) Ti2 = np.zeros(default_length, dtype=np.float32) V = np.zeros(default_length, dtype=np.float32) Cr = np.zeros(default_length, dtype=np.float32) Mn = np.zeros(default_length, dtype=np.float32) Fe = np.zeros(default_length, dtype=np.float32) Co = np.zeros(default_length, dtype=np.float32) Ni = np.zeros(default_length, dtype=np.float32) Cu = np.zeros(default_length, dtype=np.float32) Ge = np.zeros(default_length, dtype=np.float32) Ce = np.zeros(default_length, dtype=np.float32) Rb = np.zeros(default_length, dtype=np.float32) Y = np.zeros(default_length, dtype=np.float32) Nd = np.zeros(default_length, dtype=np.float32) parallax = np.zeros(default_length, dtype=np.float32) fakemag = np.zeros(default_length, dtype=np.float32) # Error array teff_err = np.zeros(default_length, dtype=np.float32) logg_err = np.zeros(default_length, dtype=np.float32) MH_err = np.zeros(default_length, dtype=np.float32) alpha_M_err = np.zeros(default_length, dtype=np.float32) C_err = np.zeros(default_length, dtype=np.float32) C1_err = np.zeros(default_length, dtype=np.float32) N_err = np.zeros(default_length, dtype=np.float32) O_err = np.zeros(default_length, dtype=np.float32) Na_err = np.zeros(default_length, dtype=np.float32) Mg_err = np.zeros(default_length, dtype=np.float32) Al_err = np.zeros(default_length, dtype=np.float32) Si_err = np.zeros(default_length, dtype=np.float32) P_err = np.zeros(default_length, dtype=np.float32) S_err = np.zeros(default_length, dtype=np.float32) K_err = np.zeros(default_length, dtype=np.float32) Ca_err = np.zeros(default_length, dtype=np.float32) Ti_err = np.zeros(default_length, dtype=np.float32) Ti2_err = np.zeros(default_length, dtype=np.float32) V_err = np.zeros(default_length, dtype=np.float32) Cr_err = np.zeros(default_length, dtype=np.float32) Mn_err = np.zeros(default_length, dtype=np.float32) Fe_err = np.zeros(default_length, dtype=np.float32) Co_err = np.zeros(default_length, dtype=np.float32) Ni_err = np.zeros(default_length, dtype=np.float32) Cu_err = np.zeros(default_length, dtype=np.float32) Ge_err = np.zeros(default_length, dtype=np.float32) Ce_err = np.zeros(default_length, dtype=np.float32) Rb_err = np.zeros(default_length, dtype=np.float32) Y_err = np.zeros(default_length, dtype=np.float32) Nd_err = np.zeros(default_length, dtype=np.float32) parallax_err = np.zeros(default_length, dtype=np.float32) fakemag_err = np.zeros(default_length, dtype=np.float32) array_counter = 0 start_time = time.time() # provide a cont mask so no need to read every loop if self.cont_mask is None: maskpath = os.path.join(astroNN.data.datapath(), f'dr{self.apogee_dr}_contmask.npy') self.cont_mask = np.load(maskpath) for counter, index in enumerate(indices): nvisits = 1 apogee_id = hdulist[1].data['APOGEE_ID'][index] location_id = hdulist[1].data['LOCATION_ID'][index] if counter % 100 == 0: print( f'Completed {counter + 1} of {indices.shape[0]}, {(time.time() - start_time):.{2}f}s elapsed' ) if not self.continuum: path = combined_spectra(dr=self.apogee_dr, location=location_id, apogee=apogee_id, verbose=0) if path is False: # if path is not found then we should skip continue combined_file = fits.open(path) _spec = combined_file[ 1].data # Pseudo-continuum normalized flux _spec_err = combined_file[2].data # Spectrum error array _spec = gap_delete( _spec, dr=self.apogee_dr) # Delete the gap between sensors _spec_err = gap_delete(_spec_err, dr=self.apogee_dr) inSNR = combined_file[0].header['SNR'] combined_file.close() else: path = visit_spectra(dr=self.apogee_dr, location=location_id, apogee=apogee_id, verbose=0) if path is False: # if path is not found then we should skip continue apstar_file = fits.open(path) nvisits = apstar_file[0].header['NVISITS'] if nvisits == 1: _spec = apstar_file[1].data _spec_err = apstar_file[2].data _spec_mask = apstar_file[3].data inSNR = np.ones(nvisits) inSNR[0] = apstar_file[0].header['SNR'] else: _spec = apstar_file[1].data[1:] _spec_err = apstar_file[2].data[1:] _spec_mask = apstar_file[3].data[1:] inSNR = np.ones(nvisits + 1) inSNR[0] = apstar_file[0].header['SNR'] for i in range(nvisits): inSNR[i + 1] = apstar_file[0].header[f'SNRVIS{i + 1}'] # Deal with spectra thats all zeros flux ii = 0 while ii < _spec.shape[0]: if np.count_nonzero(_spec[ii]) == 0: nvisits -= 1 _spec = np.delete(_spec, ii, 0) _spec_err = np.delete(_spec_err, ii, 0) _spec_mask = np.delete(_spec_mask, ii, 0) inSNR = np.delete(inSNR, ii, 0) ii -= 1 ii += 1 # Just for the sake of program to work, the real nvisits still nvisits nvisits += 1 # Normalize spectra and Set some bitmask to 0 _spec, _spec_err = self.apstar_normalization( _spec, _spec_err, _spec_mask) apstar_file.close() if nvisits == 1: individual_flag[array_counter:array_counter + nvisits] = 0 else: individual_flag[array_counter:array_counter + 1] = 0 individual_flag[array_counter + 1:array_counter + nvisits] = 1 spec[array_counter:array_counter + nvisits, :] = _spec spec_err[array_counter:array_counter + nvisits, :] = _spec_err SNR[array_counter:array_counter + nvisits] = inSNR RA[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['RA'][index], nvisits) DEC[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['DEC'][index], nvisits) parallax[array_counter:array_counter + nvisits] = np.tile( -9999, nvisits) parallax_err[array_counter:array_counter + nvisits] = np.tile( -9999, nvisits) fakemag[array_counter:array_counter + nvisits] = np.tile( -9999, nvisits) fakemag_err[array_counter:array_counter + nvisits] = np.tile( -9999, nvisits) Kmag[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['K'][index], nvisits) AK_TARG[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['AK_TARG'][index], nvisits) if self.spectra_only is not True: teff[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['PARAM'][index, 0], nvisits) logg[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['PARAM'][index, 1], nvisits) MH[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['PARAM'][index, 3], nvisits) alpha_M[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['PARAM'][index, 6], nvisits) C[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 0], nvisits) C1[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 1], nvisits) N[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 2], nvisits) O[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 3], nvisits) Na[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 4], nvisits) Mg[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 5], nvisits) Al[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 6], nvisits) Si[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 7], nvisits) P[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 8], nvisits) S[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 9], nvisits) K[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 10], nvisits) Ca[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 11], nvisits) Ti[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 12], nvisits) Ti2[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 13], nvisits) V[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 14], nvisits) Cr[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 15], nvisits) Mn[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 16], nvisits) Fe[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 17], nvisits) Co[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 18], nvisits) Ni[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 19], nvisits) Cu[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 20], nvisits) Ge[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 21], nvisits) Ce[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 22], nvisits) Rb[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 23], nvisits) Y[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 24], nvisits) Nd[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H'][index, 25], nvisits) if self.use_err is True: teff_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['TEFF_ERR'][index], nvisits) logg_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['LOGG_ERR'][index], nvisits) MH_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['M_H_ERR'][index], nvisits) alpha_M_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['ALPHA_M_ERR'][index], nvisits) C_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 0], nvisits) C1_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 1], nvisits) N_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 2], nvisits) O_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 3], nvisits) Na_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 4], nvisits) Mg_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 5], nvisits) Al_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 6], nvisits) Si_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 7], nvisits) P_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 8], nvisits) S_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 9], nvisits) K_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 10], nvisits) Ca_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 11], nvisits) Ti_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 12], nvisits) Ti2_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 13], nvisits) V_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 14], nvisits) Cr_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 15], nvisits) Mn_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 16], nvisits) Fe_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 17], nvisits) Co_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 18], nvisits) Ni_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 19], nvisits) Cu_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 20], nvisits) Ge_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 21], nvisits) Ce_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 22], nvisits) Rb_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 23], nvisits) Y_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 24], nvisits) Nd_err[array_counter:array_counter + nvisits] = np.tile( hdulist[1].data['X_H_ERR'][index, 25], nvisits) array_counter += nvisits spec = spec[0:array_counter] spec_err = spec_err[0:array_counter] individual_flag = individual_flag[0:array_counter] RA = RA[0:array_counter] DEC = DEC[0:array_counter] SNR = SNR[0:array_counter] if self.spectra_only is not True: teff = teff[0:array_counter] logg = logg[0:array_counter] Kmag = Kmag[0:array_counter] AK_TARG = AK_TARG[0:array_counter] MH = MH[0:array_counter] alpha_M = alpha_M[0:array_counter] C = C[0:array_counter] C1 = C1[0:array_counter] N = N[0:array_counter] O = O[0:array_counter] Na = Na[0:array_counter] Mg = Mg[0:array_counter] Al = Al[0:array_counter] Si = Si[0:array_counter] P = P[0:array_counter] S = S[0:array_counter] K = K[0:array_counter] Ca = Ca[0:array_counter] Ti = Ti[0:array_counter] Ti2 = Ti2[0:array_counter] V = V[0:array_counter] Cr = Cr[0:array_counter] Mn = Mn[0:array_counter] Fe = Fe[0:array_counter] Co = Co[0:array_counter] Ni = Ni[0:array_counter] Cu = Cu[0:array_counter] Ge = Ge[0:array_counter] Ce = Ce[0:array_counter] Rb = Rb[0:array_counter] Y = Y[0:array_counter] Nd = Nd[0:array_counter] parallax = parallax[0:array_counter] fakemag = fakemag[0:array_counter] teff_err = teff_err[0:array_counter] logg_err = logg_err[0:array_counter] MH_err = MH_err[0:array_counter] alpha_M_err = alpha_M_err[0:array_counter] C_err = C_err[0:array_counter] C1_err = C1_err[0:array_counter] N_err = N_err[0:array_counter] O_err = O_err[0:array_counter] Na_err = Na_err[0:array_counter] Mg_err = Mg_err[0:array_counter] Al_err = Al_err[0:array_counter] Si_err = Si_err[0:array_counter] P_err = P_err[0:array_counter] S_err = S_err[0:array_counter] K_err = K_err[0:array_counter] Ca_err = Ca_err[0:array_counter] Ti_err = Ti_err[0:array_counter] Ti2_err = Ti2_err[0:array_counter] V_err = V_err[0:array_counter] Cr_err = Cr_err[0:array_counter] Mn_err = Mn_err[0:array_counter] Fe_err = Fe_err[0:array_counter] Co_err = Co_err[0:array_counter] Ni_err = Ni_err[0:array_counter] Cu_err = Cu_err[0:array_counter] Ge_err = Ge_err[0:array_counter] Ce_err = Ce_err[0:array_counter] Rb_err = Rb_err[0:array_counter] Y_err = Y_err[0:array_counter] Nd_err = Nd_err[0:array_counter] parallax_err = parallax_err[0:array_counter] fakemag_err = fakemag_err[0:array_counter] if self.use_esa_gaia is True: gaia_ra, gaia_dec, gaia_parallax, gaia_err = gaiadr2_parallax( cuts=True, keepdims=False) m1, m2, sep = xmatch(RA, gaia_ra, maxdist=2, colRA1=RA, colDec1=DEC, colRA2=gaia_ra, colDec2=gaia_dec, swap=False) parallax[m1] = gaia_parallax[m2] parallax_err[m1] = gaia_err[m2] fakemag[m1], fakemag_err[m1] = mag_to_fakemag( extinction_correction(Kmag[m1], AK_TARG[m1]), parallax[m1], parallax_err[m1]) elif self.use_anderson_2017 is True: gaia_ra, gaia_dec, gaia_parallax, gaia_err = anderson_2017_parallax( ) m1, m2, sep = xmatch(RA, gaia_ra, maxdist=2, colRA1=RA, colDec1=DEC, epoch1=2000., colRA2=gaia_ra, colDec2=gaia_dec, epoch2=2000., swap=False) parallax[m1] = gaia_parallax[m2] parallax_err[m1] = gaia_err[m2] fakemag[m1], fakemag_err[m1] = mag_to_fakemag( extinction_correction(Kmag[m1], AK_TARG[m1]), parallax[m1], parallax_err[m1]) print(f'Creating {self.filename}.h5') h5f = h5py.File(f'{self.filename}.h5', 'w') h5f.create_dataset('spectra', data=spec) h5f.create_dataset('spectra_err', data=spec_err) h5f.create_dataset('in_flag', data=individual_flag) h5f.create_dataset('index', data=indices) if self.spectra_only is not True: h5f.create_dataset('SNR', data=SNR) h5f.create_dataset('RA', data=RA) h5f.create_dataset('DEC', data=DEC) h5f.create_dataset('Kmag', data=Kmag) h5f.create_dataset('AK_TARG', data=AK_TARG) h5f.create_dataset('teff', data=teff) h5f.create_dataset('logg', data=logg) h5f.create_dataset('M', data=MH) h5f.create_dataset('alpha', data=alpha_M) h5f.create_dataset('C', data=C) h5f.create_dataset('C1', data=C1) h5f.create_dataset('N', data=N) h5f.create_dataset('O', data=O) h5f.create_dataset('Na', data=Na) h5f.create_dataset('Mg', data=Mg) h5f.create_dataset('Al', data=Al) h5f.create_dataset('Si', data=Si) h5f.create_dataset('P', data=P) h5f.create_dataset('S', data=S) h5f.create_dataset('K', data=K) h5f.create_dataset('Ca', data=Ca) h5f.create_dataset('Ti', data=Ti) h5f.create_dataset('Ti2', data=Ti2) h5f.create_dataset('V', data=V) h5f.create_dataset('Cr', data=Cr) h5f.create_dataset('Mn', data=Mn) h5f.create_dataset('Fe', data=Fe) h5f.create_dataset('Co', data=Co) h5f.create_dataset('Ni', data=Ni) h5f.create_dataset('Cu', data=Cu) h5f.create_dataset('Ge', data=Ge) h5f.create_dataset('Ce', data=Ce) h5f.create_dataset('Rb', data=Rb) h5f.create_dataset('Y', data=Y) h5f.create_dataset('Nd', data=Nd) h5f.create_dataset('parallax', data=parallax) h5f.create_dataset('fakemag', data=fakemag) if self.use_err is True: h5f.create_dataset('AK_TARG_err', data=np.zeros_like(AK_TARG)) h5f.create_dataset('teff_err', data=teff_err) h5f.create_dataset('logg_err', data=logg_err) h5f.create_dataset('M_err', data=MH_err) h5f.create_dataset('alpha_err', data=alpha_M_err) h5f.create_dataset('C_err', data=C_err) h5f.create_dataset('C1_err', data=C1_err) h5f.create_dataset('N_err', data=N_err) h5f.create_dataset('O_err', data=O_err) h5f.create_dataset('Na_err', data=Na_err) h5f.create_dataset('Mg_err', data=Mg_err) h5f.create_dataset('Al_err', data=Al_err) h5f.create_dataset('Si_err', data=Si_err) h5f.create_dataset('P_err', data=P_err) h5f.create_dataset('S_err', data=S_err) h5f.create_dataset('K_err', data=K_err) h5f.create_dataset('Ca_err', data=Ca_err) h5f.create_dataset('Ti_err', data=Ti_err) h5f.create_dataset('Ti2_err', data=Ti2_err) h5f.create_dataset('V_err', data=V_err) h5f.create_dataset('Cr_err', data=Cr_err) h5f.create_dataset('Mn_err', data=Mn_err) h5f.create_dataset('Fe_err', data=Fe_err) h5f.create_dataset('Co_err', data=Co_err) h5f.create_dataset('Ni_err', data=Ni_err) h5f.create_dataset('Cu_err', data=Cu_err) h5f.create_dataset('Ge_err', data=Ge_err) h5f.create_dataset('Ce_err', data=Ce_err) h5f.create_dataset('Rb_err', data=Rb_err) h5f.create_dataset('Y_err', data=Y_err) h5f.create_dataset('Nd_err', data=Nd_err) h5f.create_dataset('parallax_err', data=parallax_err) h5f.create_dataset('fakemag_err', data=fakemag_err) h5f.close() print(f'Successfully created {self.filename}.h5 in {currentdir}')