def openObservedStack(self, fluxKeyword='medianWeightedStack'): """ It reads an Stack spectrum from the LF analysis and provides the input for the firefly fitting routine. :param fluxKeyword: parameter to choose the mean or the median stack 'meanWeightedStack', 'medianWeightedStack' """ self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = 0. #self.hdulist[0].header['RA'] self.dec = 0. #self.hdulist[0].header['DEC'] self.redshift = float( os.path.basename( self.path_to_spectrum).split('-')[-1].split('_')[0][1:]) self.restframe_wavelength = self.hdulist[1].data['wavelength'] self.wavelength = self.restframe_wavelength * (1. + self.redshift) meanWL = (self.wavelength[1:] + self.wavelength[:-1]) / 2. deltaWL = self.wavelength[1:] - self.wavelength[:-1] resolution = np.ones_like(self.wavelength) * np.mean(meanWL / deltaWL) #self.flux = self.hdulist[1].data['meanWeightedStack'] * 1e17 self.flux = self.hdulist[1].data[fluxKeyword] * 1e17 self.error = self.hdulist[1].data['jackknifStackErrors'] * 1e17 self.bad_flags = np.ones(len(self.restframe_wavelength)) Nstacked = float(self.path_to_spectrum.split('-')[-1].split('_')[3]) lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked) ) | (self.hdulist[1].data['NspectraPerPixel'] < Nstacked * 0.8) | (self.flux == -9999.99) self.restframe_wavelength = self.restframe_wavelength[( lines_mask == False)] self.wavelength = self.wavelength[(lines_mask == False)] influx = self.flux[(lines_mask == False)] inerror = self.error[(lines_mask == False)] inbad_flags = self.bad_flags[(lines_mask == False)] self.flux, self.error, self.bad_flags = remove_bad_data( influx, inerror, inbad_flags) self.r_instrument = resolution[(lines_mask == False)] self.vdisp = 70. # km/s self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openObservedMuseSpectrum(self, catalog): """Loads an observed MUSE spectrum in counts. :param catalog: name of the catalog with redshifts. """ self.wavelength, flA, flErrA = np.loadtxt(self.path_to_spectrum, unpack=True) self.flux, self.error = flA * 1e-3, flErrA * 1e-3 # units of 1e-17 self.bad_flags = np.ones(len(self.wavelength)) bad_data = np.isnan(self.flux) | np.isinf(self.flux) | ( self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 self.redshift = catalog['FINAL_Z'] self.vdisp = 100 # catalog['VDISP'] self.restframe_wavelength = self.wavelength / (1.0 + self.redshift) # masking emission lines lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[( lines_mask == False)] self.wavelength = self.wavelength[(lines_mask == False)] self.flux = self.flux[(lines_mask == False)] self.error = self.error[(lines_mask == False)] self.bad_flags = self.bad_flags[(lines_mask == False)] self.r_instrument = np.zeros(len(self.wavelength)) for wi, w in enumerate(self.wavelength): if w < 6000: self.r_instrument[wi] = (2270.0 - 1560.0) / ( 6000.0 - 3700.0) * w + 420.0 else: self.r_instrument[wi] = (2650.0 - 1850.0) / ( 9000.0 - 6000.0) * w + 250.0 self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(catalog['ALPHA'], catalog['DELTA'], 'ebv') else: self.ebv_mw = 0.
def openStackEBOSS(self, redshift=0.85, fluxKeyword='medianWeightedStack'): self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = 0. #self.hdulist[0].header['RA'] self.dec = 0. #self.hdulist[0].header['DEC'] self.redshift = redshift self.restframe_wavelength = self.hdulist[1].data['wavelength'] self.wavelength = self.restframe_wavelength * (1. + self.redshift) meanWL = (self.wavelength[1:] + self.wavelength[:-1]) / 2. deltaWL = self.wavelength[1:] - self.wavelength[:-1] resolution = np.ones_like(self.wavelength) * np.mean(meanWL / deltaWL) self.flux = self.hdulist[1].data[fluxKeyword] #* 10**(-17) self.error = self.hdulist[1].data['jackknifStackErrors'] #* 10**(-17) self.bad_flags = np.ones(len(self.restframe_wavelength)) lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[( lines_mask == False)] self.wavelength = self.wavelength[(lines_mask == False)] self.flux = self.flux[(lines_mask == False)] self.error = self.error[(lines_mask == False)] self.bad_flags = self.bad_flags[(lines_mask == False)] self.r_instrument = resolution[(lines_mask == False)] bad_data = np.isnan(self.flux) | np.isinf(self.flux) | ( self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 self.vdisp = 70. # km/s self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openSAMIgalaxy(self, xposition, yposition): from astropy.io import fits header = fits.open(self.path_to_spectrum) #print( header['PRIMARY'].header) stop # Open up the header to get key information to construct wavelength vector. crval3, cdelt, naxis, crpix = header['PRIMARY'].header[ 'CRVAL3'], header['PRIMARY'].header['CDELT3'], header[ 'PRIMARY'].header['NAXIS3'], header['PRIMARY'].header['CRPIX3'] crval = crval3 - (crpix * cdelt) wavelength = np.arange(naxis) * cdelt + crval # Now open up the flux and variance for an arbitrary spaxel. Use the variance to get error spectrum. flux, variance = header[ 'PRIMARY'].data[:, xposition, yposition], header['VARIANCE'].data[:, xposition, yposition] error = np.sqrt(variance) # Redshift, sigma etc. redshift, ra, dec = 0.050, 214.36654, 0.48281 restframe_wavelength = wavelength / (1 + redshift) vdisp = 100 bad_flags = np.ones(len(restframe_wavelength)) bad_data = np.isnan(flux) | np.isinf(flux) | ( flux <= 0.0) | np.isnan(error) | np.isinf(error) flux[bad_data] = 0.0 error[bad_data] = np.max(flux) * 99999999999.9 bad_flags[bad_data] = 0 resolution = np.ones_like(wavelength) * 1700 self.xpos, self.ypos, self.redshift, self.restframe_wavelength, self.wavelength = ra, dec, redshift, restframe_wavelength, wavelength self.flux, self.error, self.bad_flags, self.r_instrument, self.vdisp = flux, error, bad_flags, resolution, vdisp self.trust_flag, self.objid = True, '' #import matplotlib.pyplot as plt #plt.plot(restframe_wavelength, flux, 'r') #plt.show() #stop if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(ra, dec, 'ebv') else: self.ebv_mw = 0.0
def openEllipticalsSMG(self): hdulist = pyfits.open(self.path_to_spectrum) hdulist.info() ra = hdulist[0].header['RA'] dec = hdulist[0].header['DEC'] redshift = hdulist[0].header['REDSHIFT'] naxis1 = hdulist[0].header['NAXIS1'] cdelt1 = hdulist[0].header['CDELT1'] crval1 = hdulist[0].header['CRVAL1'] crval2 = hdulist[0].header['CRVAL2'] restframe_wavelength = np.arange(crval1, crval2, cdelt1) wavelength = restframe_wavelength * (1. + redshift) meanWL = (wavelength[1:] + wavelength[:-1]) / 2. deltaWL = hdulist[0].header['FWHM'] resolution = np.ones_like(wavelength) * np.mean(meanWL / deltaWL) vdisp = hdulist[0].header['VELDISP'] flux = hdulist[0].data error = np.zeros(len(flux)) bad_flags = np.ones(len(restframe_wavelength)) bad_data = np.isnan(flux) | np.isinf(flux) | ( flux <= 0.0) | np.isnan(error) | np.isinf(error) # removes the bad data from the spectrum flux[bad_data] = 0.0 error[bad_data] = np.max(flux) * 99999999999.9 bad_flags[bad_data] = 0 #import matplotlib.pyplot as plt #plt.plot(wavelength, flux, 'r') #plt.show() #stop self.xpos, self.ypos, self.redshift, self.restframe_wavelength, self.wavelength = ra, dec, redshift, restframe_wavelength, wavelength self.flux, self.error, self.bad_flags, self.r_instrument, self.vdisp = flux, error, bad_flags, resolution, vdisp self.trust_flag, self.objid = True, '' if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(ra, dec, 'ebv') else: self.ebv_mw = 0.0
def openStackEBOSS(self, redshift = 0.85): self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = 0. #self.hdulist[0].header['RA'] self.dec = 0. #self.hdulist[0].header['DEC'] self.redshift = redshift self.restframe_wavelength = self.hdulist[1].data['wavelength'] self.wavelength = self.restframe_wavelength * (1. + self.redshift) meanWL = (self.wavelength[1:]+self.wavelength[:-1])/2. deltaWL = self.wavelength[1:]-self.wavelength[:-1] resolution = np.ones_like(self.wavelength)*np.mean(meanWL / deltaWL) self.flux = self.hdulist[1].data['meanWeightedStack'] #* 10**(-17) self.error = self.hdulist[1].data['jackknifStackErrors'] #* 10**(-17) self.bad_flags = np.ones(len(self.restframe_wavelength)) lines_mask = ((self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[(lines_mask==False)] self.wavelength = self.wavelength[(lines_mask==False)] self.flux = self.flux[(lines_mask==False)] self.error = self.error[(lines_mask==False)] self.bad_flags = self.bad_flags[(lines_mask==False)] self.r_instrument = resolution[(lines_mask==False)] bad_data = np.isnan(self.flux) | np.isinf(self.flux) | (self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 self.vdisp = 70. # km/s self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening : # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra,self.dec,'ebv') else: self.ebv_mw = 0.0 print"there are", len(self.wavelength),"data points at redshift",self.redshift," between", np.min(self.wavelength[bad_data==False]), np.max(self.wavelength[bad_data==False]), "Angstrom.", np.min(self.restframe_wavelength[bad_data==False]), np.max(self.restframe_wavelength[bad_data==False]), "Angstrom in the rest frame."
def stack_no_lines(self, redshift=0.85, fluxKeyword='medianWeightedStack'): #for use with stacked spectra with removed emission lines #created for stacked eBOSS spectra with emission lines removed with DAP self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = 0. #self.hdulist[0].header['RA'] self.dec = 0. #self.hdulist[0].header['DEC'] self.redshift = 0 self.restframe_wavelength = self.hdulist[1].data self.wavelength = self.restframe_wavelength * (1. + self.redshift) meanWL = (self.wavelength[1:] + self.wavelength[:-1]) / 2. deltaWL = self.wavelength[1:] - self.wavelength[:-1] resolution = np.ones_like(self.wavelength) * np.mean(meanWL / deltaWL) self.flux = self.hdulist[2].data #* 10**(-17) self.error = self.hdulist[3].data #* 10**(-17) self.bad_flags = np.ones(len(self.restframe_wavelength)) #lines_mask = ((self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) lines_mask = np.full(len(self.wavelength), False, dtype=bool) self.restframe_wavelength = self.restframe_wavelength[( lines_mask == False)] self.wavelength = self.wavelength[(lines_mask == False)] influx = self.flux[(lines_mask == False)] inerror = self.error[(lines_mask == False)] inbad_flags = self.bad_flags[(lines_mask == False)] self.flux, self.error, self.bad_flags = remove_bad_data( influx, inerror, inbad_flags) self.r_instrument = resolution[(lines_mask == False)] self.vdisp = self.hdulist[4].data[0] # km/s self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openObservedMuseSpectrum(self, catalog): """Loads the observed spectrum in counts.""" self.wavelength, flA, flErrA = np.loadtxt(self.path_to_spectrum, unpack=True) self.flux, self.error = flA*1e-3, flErrA*1e-3 # units of 1e-17 self.bad_flags = np.ones(len(self.wavelength)) bad_data = np.isnan(self.flux) | np.isinf(self.flux) | (self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 self.redshift = catalog['FINAL_Z'] self.vdisp = 100 # catalog['VDISP'] self.restframe_wavelength = self.wavelength / (1.0+self.redshift) # masking emission lines lines_mask = ((self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[(lines_mask==False)] self.wavelength = self.wavelength[(lines_mask==False)] self.flux = self.flux[(lines_mask==False)] self.error = self.error[(lines_mask==False)] self.bad_flags = self.bad_flags[(lines_mask==False)] self.r_instrument = np.zeros(len(self.wavelength)) for wi,w in enumerate(self.wavelength): if w<6000: self.r_instrument[wi] = (2270.0-1560.0)/(6000.0-3700.0)*w + 420.0 else: self.r_instrument[wi] = (2650.0-1850.0)/(9000.0-6000.0)*w + 250.0 self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening : # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(catalog['ALPHA'], catalog['DELTA'], 'ebv') else: self.ebv_mw = 0.0
def openSingleSpectrum(self, wavelength, flux, error, redshift, ra, dec, vdisp, lines_mask, r_instrument): self.wavelength = wavelength self.flux = flux self.error = error self.redshift = redshift self.ra = ra self.dec = dec self.vdisp = vdisp self.lines_mask = lines_mask self.r_instrument = r_instrument self.DL = cosmo.luminosity_distance(self.redshift).to(uu.cm) self.bad_flags = np.ones(len(self.wavelength)) self.bad_flags = self.bad_flags[(self.lines_mask == False)] self.restframe_wavelength = self.wavelength / (1 + self.redshift) self.trust_flag = 1 self.objid = 0 self.restframe_wavelength = self.restframe_wavelength[( self.lines_mask == False)] self.wavelength = self.wavelength[(self.lines_mask == False)] self.flux = self.flux[(self.lines_mask == False)] self.error = self.error[(self.lines_mask == False)] # removes the bad data from the spectrum self.bad_data = np.isnan(self.flux) | np.isinf(self.flux) | ( self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) self.flux[self.bad_data] = 0.0 self.error[self.bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[self.bad_data] = 0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openGCsUsher(self): hdulist = pyfits.open(self.path_to_spectrum) hdulist.info() ra = hdulist[0].header['RA'] dec = hdulist[0].header['DEC'] redshift = hdulist[0].header['REDSHIFT'] naxis1 = hdulist[0].header['NAXIS2'] cdelt1 = hdulist[0].header['CDELT1'] crval1 = hdulist[0].header['CRVAL1'] crval2 = hdulist[0].header['CRVAL2'] restframe_wavelength = np.arange(crval1, crval2, cdelt1) wavelength = restframe_wavelength * (1. + redshift) meanWL = (wavelength[1:] + wavelength[:-1]) / 2. deltaWL = hdulist[0].header['FWHM'] resolution = np.ones_like(wavelength) * np.mean(meanWL / deltaWL) vdisp = hdulist[0].header['VELDISP'] influx = hdulist[0].data influx = influx.flatten() inerror = hdulist[1].data inerror = inerror.flatten() inbad_flags = np.ones(len(restframe_wavelength)) flux, error, bad_flags = remove_bad_data(influx, inerror, inbad_flags) self.xpos, self.ypos, self.redshift, self.restframe_wavelength, self.wavelength = ra, dec, redshift, restframe_wavelength, wavelength self.flux, self.error, self.bad_flags, self.r_instrument, self.vdisp = flux, error, bad_flags, resolution, vdisp self.trust_flag, self.objid = True, '' if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(ra, dec, 'ebv') else: self.ebv_mw = 0.0
def openObservedSDSSSpectrum(self, survey='sdssMain'): """ It reads an SDSS spectrum and provides the input for the firefly fitting routine. In this aims, it stores the following data in the object : * hdu list from the spec lite * SED data : wavelength (in angstrom), flux, error on the flux (in 10^{-17} erg/cm2/s/Angstrom, like the SDSS spectra) * Metadata : * ra : in degrees J2000 * dec : in degrees J2000 * redshift : best fit * vdisp : velocity dispersion in km/s * r_instrument : resolution of the instrument at each wavelength observed * trust_flag : 1 or True if trusted * bad_flags : ones as long as the wavelength array, filters the pixels with bad data * objid : object id optional : set to 0 """ self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = self.hdulist[0].header['RA'] self.dec = self.hdulist[0].header['DEC'] self.wavelength = 10**self.hdulist[1].data['loglam'] self.flux = self.hdulist[1].data['flux'] self.error = self.hdulist[1].data['ivar']**(-0.5) self.bad_flags = np.ones(len(self.wavelength)) if survey == 'sdssMain': self.redshift = self.hdulist[2].data['Z'][0] if survey == 'sdss3': self.redshift = self.hdulist[2].data['Z_NOQSO'][0] if survey == 'sdss4': self.redshift = self.hdulist[2].data['Z_NOQSO'][0] self.vdisp = self.hdulist[2].data['VDISP'][0] self.restframe_wavelength = self.wavelength / (1.0 + self.redshift) self.trust_flag = 1 self.objid = 0 # masking emission lines lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[( lines_mask == False)] self.wavelength = self.wavelength[(lines_mask == False)] influx = self.flux[(lines_mask == False)] inerror = self.error[(lines_mask == False)] inbad_flags = self.bad_flags[(lines_mask == False)] self.flux, self.error, self.bad_flags = remove_bad_data( influx, inerror, inbad_flags) self.r_instrument = np.zeros(len(self.wavelength)) for wi, w in enumerate(self.wavelength): if w < 6000: self.r_instrument[wi] = (2270.0 - 1560.0) / ( 6000.0 - 3700.0) * w + 420.0 else: self.r_instrument[wi] = (2650.0 - 1850.0) / ( 9000.0 - 6000.0) * w + 250.0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openObservedStackTutorial(self): """ It reads an Stack spectrum from the LF analysis and provides the input for the firefly fitting routine. :param path_to_spectrum: :param sdss_dir: directory with the observed spectra :param milky_way_reddening: True or False if you want to correct the redenning of the Milky way. :param hpf_mode: 'on' high pass filters the data to correct from dust in the galaxy. In this aims, it stores the following data in the object : * hdu list from the spec lite * SED data : wavelength (in angstrom), flux, error on the flux (in 10^{-17} erg/cm2/s/Angstrom, like the SDSS spectra) * Metadata : * ra : in degrees J2000 * dec : in degrees J2000 * redshift : best fit * vdisp : velocity dispersion in km/s * r_instrument : resolution of the instrument at each wavelength observed * trust_flag : 1 or True if trusted * bad_flags : ones as long as the wavelength array, filters the pixels with bad data * objid : object id optional : set to 0 """ self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = 0. #self.hdulist[0].header['RA'] self.dec = 0. #self.hdulist[0].header['DEC'] self.redshift = float( os.path.basename( self.path_to_spectrum).split('-')[-1].split('_')[0][1:]) self.restframe_wavelength = self.hdulist[1].data['WAVE'][0] self.wavelength = self.restframe_wavelength * (1. + self.redshift) meanWL = (self.wavelength[1:] + self.wavelength[:-1]) / 2. deltaWL = self.wavelength[1:] - self.wavelength[:-1] resolution = np.ones_like(self.wavelength) * np.mean(meanWL / deltaWL) # units of 1e-17 f lambda self.flux = self.hdulist[1].data['FLUXMEDIAN'][0] # * 1e-17 self.error = self.hdulist[1].data['FLUXMEDIAN_ERR'][0] # * 1e-17 self.bad_flags = np.ones(len(self.restframe_wavelength)) Nstacked = float(self.path_to_spectrum.split('-')[-1].split('_')[3]) lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[( lines_mask == False)] self.wavelength = self.wavelength[(lines_mask == False)] influx = self.flux[(lines_mask == False)] inerror = self.error[(lines_mask == False)] inbad_flags = self.bad_flags[(lines_mask == False)] self.flux, self.error, self.bad_flags = remove_bad_data( influx, inerror, inbad_flags) self.r_instrument = resolution[(lines_mask == False)] self.vdisp = 70. # km/s self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openObservedMANGASpectrum(self, data_release, path_to_logcube, path_to_drpall, bin_number, plate_number, ifu_number): """Loads an observed MaNGA spectrum in. :param data_release: Must specify which data release of MaNGA you are using, as file structure has changed. :param data_release: Must specify the path to logcube (if using MPL5 or higher). Set to 0 otherwise. """ if data_release == 'MPL5': # Read in MAPS file as this contains part of the information. maps_header = pyfits.open(self.path_to_spectrum) bin_identification = maps_header['BINID'].data where = np.where(bin_number == bin_identification) x_position, y_position = where[0][0], where[1][0] # Get S/N, right ascension and declination. signal, ra, dec = maps_header['BIN_SNR'].data[ x_position, y_position], maps_header[0].header[ 'OBJRA'], maps_header[0].header['OBJDEC'] # Correct sigma for instrumental resolution velocity_dispersion_wrong = maps_header['STELLAR_SIGMA'].data velocity_dispersion_correction = maps_header[ 'STELLAR_SIGMACORR'].data if velocity_dispersion_wrong[ x_position, y_position] > velocity_dispersion_correction[x_position, y_position]: correction = np.sqrt( (velocity_dispersion_wrong[x_position, y_position])**2 - (velocity_dispersion_correction[x_position, y_position])**2) vdisp = correction else: correction = cmath.sqrt( (velocity_dispersion_wrong[x_position, y_position])**2 - (velocity_dispersion_correction[x_position, y_position])**2) vdisp = velocity_dispersion_wrong[x_position, y_position] # Open LOGCUBE to get the flux, wavelength, and error header = pyfits.open(path_to_logcube) wavelength, flux, emline, emline_base, bit_mask, inverse_variance = header[ 'WAVE'].data, header['FLUX'].data, header[ 'EMLINE'].data, header['EMLINE_BASE'].data, header[ 'MASK'].data, header['IVAR'].data self.wavelength = wavelength correct_flux = flux[:, x_position, y_position] correct_flux_emline = emline[:, x_position, y_position] output_flux = correct_flux - correct_flux_emline correct_inverse_variance = inverse_variance[:, x_position, y_position] self.error = np.sqrt(1.0 / (correct_inverse_variance)) self.bad_flags = np.ones(len(output_flux)) self.flux = output_flux self.vdisp = vdisp # Open drp all file to get the correct redshift of the galaxy. dap_all = pyfits.open(path_to_drpall) main_header, manga_plate, manga_ifu, manga_redshift = dap_all[ 1].data, [], [], [] for q in range(len(main_header)): galaxy = main_header[q] plate, ifu, z = galaxy['plate'], galaxy['ifudsgn'], galaxy[ 'nsa_z'] manga_plate.append(plate) manga_ifu.append(ifu) manga_redshift.append(z) manga_plate, manga_ifu, manga_redshift = np.array( manga_plate, dtype=int), np.array(manga_ifu, dtype=int), np.array(manga_redshift) where = np.where((manga_plate == int(plate_number))) ifu_sorted = manga_ifu[where] redshift_sorted = manga_redshift[where] where_1 = np.where(int(ifu_number) == ifu_sorted) redshift = redshift_sorted[where_1][0] self.restframe_wavelength = wavelength / (1.0 + redshift) self.redshift = redshift # Get Trust flag, object_id, xpos, ypos and instrumental resolution. self.trust_flag, self.objid, self.r_instrument = True, 0, np.loadtxt( '../bin_MaNGA/MaNGA_spectral_resolution.txt') self.xpos, self.ypos = ra, dec if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(ra, dec, 'ebv') else: self.ebv_mw = 0.0
def openSDSSSpectrum(self, survey): """ It reads an SDSS spectrum and provides the input for the firefly fitting routine. In this aims, it stores the following data in the object : * hdu list from the spec lite * SED data : wavelength (in angstrom), flux, error on the flux (in 10^{-17} erg/cm2/s/Angstrom, like the SDSS spectra) * Metadata : * ra : in degrees J2000 * dec : in degrees J2000 * redshift : best fit * vdisp : velocity dispersion in km/s * r_instrument : resolution of the instrument at each wavelength observed * trust_flag : 1 or True if trusted * bad_flags : ones as long as the wavelength array, filters the pixels with bad data * objid : object id optional : set to 0 """ maskLambda = np.loadtxt(os.path.join(os.environ['FF_DIR'], 'data', "dr12-sky-mask.txt"), unpack=True) self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = self.hdulist[0].header['RA'] self.dec = self.hdulist[0].header['DEC'] self.wavelength = 10**self.hdulist[1].data['loglam'] self.flux = self.hdulist[1].data['flux'] self.error = self.hdulist[1].data['ivar']**(-0.5) self.bad_flags = np.ones(len(self.wavelength)) if survey == 'sdssMain': self.redshift = self.hdulist[2].data['Z'][0] if survey == 'sdss3': self.redshift = self.hdulist[2].data['Z_NOQSO'][0] if survey == 'sdss4': self.redshift = self.hdulist[2].data['Z_NOQSO'][0] self.vdisp = self.hdulist[2].data['VDISP'][0] self.restframe_wavelength = self.wavelength / (1.0 + self.redshift) self.trust_flag = 1 self.objid = 0 ratio = np.min(abs( 10000. * np.log10(np.outer(self.wavelength, 1. / maskLambda))), axis=1) margin = 1.5 vet_mask = ratio <= margin # masking emission lines if testing: lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ( (self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked) ) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked) ) | (self.restframe_wavelength < 3900) | (self.restframe_wavelength > 6800) else: lines_mask = ( (self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked) ) | ( (self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked) ) | ( (self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked) ) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[ (lines_mask == False) & (vet_mask == False)] self.wavelength = self.wavelength[(lines_mask == False) & (vet_mask == False)] self.flux = self.flux[(lines_mask == False) & (vet_mask == False)] self.error = self.error[(lines_mask == False) & (vet_mask == False)] self.bad_flags = self.bad_flags[(lines_mask == False) & (vet_mask == False)] bad_data = np.isnan(self.flux) | np.isinf(self.flux) | ( self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 f_blue = lambda lll: (2270.0 - 1560.0) / (6000.0 - 3700.0 ) * lll + 420.0 f_red = lambda lll: (2650.0 - 1850.0) / (9000.0 - 6000.0) * lll + 250.0 self.r_instrument = np.zeros(len(self.wavelength)) self.r_instrument[(self.wavelength < 6000.)] = f_blue( self.wavelength[(self.wavelength < 6000.)]) self.r_instrument[(self.wavelength >= 6000.)] = f_red( self.wavelength[(self.wavelength >= 6000.)]) if self.milky_way_reddening: # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra, self.dec, 'ebv') else: self.ebv_mw = 0.0
def openObservedSDSSSpectrum(self): """ It reads an SDSS spectrum and provides the input for the firefly fitting routine. :param path_to_spectrum: :param sdss_dir: directory with the observed spectra :param milky_way_reddening: True or False if you want to correct the redenning of the Milky way. :param hpf_mode: 'on' high pass filters the data to correct from dust in the galaxy. In this aims, it stores the following data in the object : * hdu list from the spec lite * SED data : wavelength (in angstrom), flux, error on the flux (in 10^{-17} erg/cm2/s/Angstrom, like the SDSS spectra) * Metadata : * ra : in degrees J2000 * dec : in degrees J2000 * redshift : best fit * vdisp : velocity dispersion in km/s * r_instrument : resolution of the instrument at each wavelength observed * trust_flag : 1 or True if trusted * bad_flags : ones as long as the wavelength array, filters the pixels with bad data * objid : object id optional : set to 0 """ self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = self.hdulist[0].header['RA'] self.dec = self.hdulist[0].header['DEC'] self.wavelength = 10**self.hdulist[1].data['loglam'] self.flux = self.hdulist[1].data['flux'] self.error = self.hdulist[1].data['ivar']**(-0.5) self.bad_flags = np.ones(len(self.wavelength)) self.redshift = self.hdulist[2].data['Z'][0] self.vdisp = self.hdulist[2].data['VDISP'][0] self.restframe_wavelength = self.wavelength / (1.0+self.redshift) self.trust_flag = 1 self.objid = 0 # masking emission lines lines_mask = ((self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[(lines_mask==False)] self.wavelength = self.wavelength[(lines_mask==False)] self.flux = self.flux[(lines_mask==False)] self.error = self.error[(lines_mask==False)] self.bad_flags = self.bad_flags[(lines_mask==False)] bad_data = np.isnan(self.flux) | np.isinf(self.flux) | (self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 self.r_instrument = np.zeros(len(self.wavelength)) for wi,w in enumerate(self.wavelength): if w<6000: self.r_instrument[wi] = (2270.0-1560.0)/(6000.0-3700.0)*w + 420.0 else: self.r_instrument[wi] = (2650.0-1850.0)/(9000.0-6000.0)*w + 250.0 if self.milky_way_reddening : # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra,self.dec,'ebv') else: self.ebv_mw = 0.0
def openObservedStackTutorial(self): """ It reads an Stack spectrum from the LF analysis and provides the input for the firefly fitting routine. :param path_to_spectrum: :param sdss_dir: directory with the observed spectra :param milky_way_reddening: True or False if you want to correct the redenning of the Milky way. :param hpf_mode: 'on' high pass filters the data to correct from dust in the galaxy. In this aims, it stores the following data in the object : * hdu list from the spec lite * SED data : wavelength (in angstrom), flux, error on the flux (in 10^{-17} erg/cm2/s/Angstrom, like the SDSS spectra) * Metadata : * ra : in degrees J2000 * dec : in degrees J2000 * redshift : best fit * vdisp : velocity dispersion in km/s * r_instrument : resolution of the instrument at each wavelength observed * trust_flag : 1 or True if trusted * bad_flags : ones as long as the wavelength array, filters the pixels with bad data * objid : object id optional : set to 0 """ self.hdulist = pyfits.open(self.path_to_spectrum) self.ra = 0. #self.hdulist[0].header['RA'] self.dec = 0. #self.hdulist[0].header['DEC'] self.redshift = float(os.path.basename(self.path_to_spectrum).split('-')[-1].split('_')[0][1:]) self.restframe_wavelength = self.hdulist[1].data['WAVE'][0] self.wavelength = self.restframe_wavelength * (1. + self.redshift) meanWL = (self.wavelength[1:]+self.wavelength[:-1])/2. deltaWL = self.wavelength[1:]-self.wavelength[:-1] resolution = np.ones_like(self.wavelength)*np.mean(meanWL / deltaWL) # units of 1e-17 f lambda self.flux = self.hdulist[1].data['FLUXMEDIAN'][0]# * 1e-17 self.error = self.hdulist[1].data['FLUXMEDIAN_ERR'][0]# * 1e-17 self.bad_flags = np.ones(len(self.restframe_wavelength)) Nstacked = float(self.path_to_spectrum.split('-')[-1].split('_')[3]) lines_mask = ((self.restframe_wavelength > 3728 - self.N_angstrom_masked) & (self.restframe_wavelength < 3728 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 5007 - self.N_angstrom_masked) & (self.restframe_wavelength < 5007 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 4861 - self.N_angstrom_masked) & (self.restframe_wavelength < 4861 + self.N_angstrom_masked)) | ((self.restframe_wavelength > 6564 - self.N_angstrom_masked) & (self.restframe_wavelength < 6564 + self.N_angstrom_masked)) self.restframe_wavelength = self.restframe_wavelength[(lines_mask==False)] self.wavelength = self.wavelength[(lines_mask==False)] self.flux = self.flux[(lines_mask==False)] self.error = self.error[(lines_mask==False)] self.bad_flags = self.bad_flags[(lines_mask==False)] self.r_instrument = resolution[(lines_mask==False)] bad_data = np.isnan(self.flux) | np.isinf(self.flux) | (self.flux <= 0.0) | np.isnan(self.error) | np.isinf(self.error) # removes the bad data from the spectrum self.flux[bad_data] = 0.0 self.error[bad_data] = np.max(self.flux) * 99999999999.9 self.bad_flags[bad_data] = 0 self.vdisp = 70. # km/s self.trust_flag = 1 self.objid = 0 if self.milky_way_reddening : # gets the amount of MW reddening on the models self.ebv_mw = get_dust_radec(self.ra,self.dec,'ebv') else: self.ebv_mw = 0.0 print"there are", len(self.wavelength),"data points at redshift",self.redshift," between", np.min(self.wavelength[bad_data==False]), np.max(self.wavelength[bad_data==False]), "Angstrom.", np.min(self.restframe_wavelength[bad_data==False]), np.max(self.restframe_wavelength[bad_data==False]), "Angstrom in the rest frame."