def spec_generator(folder_data, obj_list, flux_norm, idx_start=0):
for idx_obj, obj_name in enumerate(obj_list[idx_start:]):
wave, data, hdrs = sr.import_fits_data(folder_data /
f'{obj_name}.fits',
instrument='SDSS')
flux = data['flux'] * flux_norm
z_i = hdrs[1]["z"][0]
lm = sr.LineMesurer(wave,
flux,
redshift=z_i,
normFlux=normFlux,
crop_waves=(1 + z_i) *
np.array([4685 - 100, 5100]))
yield idx_obj, obj_name, lm.wave, lm.flux
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt, rcParams
from pathlib import Path
import src.specsiser as ss
linesFile = Path(
'D:/Pycharm Projects/spectra-synthesizer/src/specsiser/literature_data/lines_data.xlsx'
)
linesDb = pd.read_excel(linesFile, sheet_name=0, header=0, index_col=0)
data_folder = Path('D:/Dropbox/Astrophysics/Data/WHT-Ricardo/')
fileList = ['COMBINED_blue.0001.fits', 'combined_red.0001.fits']
addressList = list(data_folder / file for file in fileList)
# Get the fits file data
wave_blue, flux_blue, header_blue = ss.import_fits_data(addressList[0], 0)
wave_red, flux_red, header_red = ss.import_fits_data(addressList[1], 0)
# Redshift correction
redshift, blue_limits = 1.1735, (3600, 5100)
wave_blue = wave_blue / redshift
wave_red = wave_red / redshift
# Trim the observation
idcs_limit = (blue_limits[0] <= wave_blue) & (wave_blue <= blue_limits[1])
wave_blue, flux_blue = wave_blue[idcs_limit], flux_blue[idcs_limit]
lm = ss.EmissionFitting(wave_blue, flux_blue)
# Remove the continuum
flux_noContinuum = lm.continuum_remover(noiseWaveLim=(4150, 4300))
flux_norm = obsData['sample_data']['norm_flux']
i_obj = 2
obj = objList[i_obj]
ext = '_BR'
cycle = 'c2'
for i_obj, obj in enumerate(objList):
if i_obj < 3:
print(f'Treating: {obj}')
objFolder = resultsFolder / f'{obj}'
lineLog_file = objFolder / f'{obj}{ext}_linesLog_{cycle}.txt'
linesDF = sr.lineslogFile_to_DF(lineLog_file)
fits_file = dataFolder / f'{obj}{ext}.fits'
wave, flux, header = sr.import_fits_data(fits_file,
instrument='OSIRIS')
lm = sr.LineMesurer(wave,
flux,
redshift=z_objs[i_obj],
normFlux=flux_norm,
crop_waves=(wmin_array[i_obj], wmax_array[i_obj]))
fits_blue_file = dataFolder / f'{obj}_B.fits'
wave_b, flux, header_b = sr.import_fits_data(fits_blue_file,
instrument='OSIRIS')
flux_b = flux[idx_band][0]
lm_b = sr.LineMesurer(wave_b,
flux_b,
redshift=z_objs[i_obj],
normFlux=flux_norm,
crop_waves=(wmin_array[i_obj],
# Inputs location
print(f'\n- Treating {obj} ({i}/{len(objList)})')
fits_address = fits_folder / f'{obj}.fits'
objFolder = results_folder / 'line_measurements' / obj
local_mask = objFolder / f'mask_{obj}.txt'
# Outputs location
local_lineslog = objFolder / f'lineslog_{obj}.txt'
pdf_lineslog = objFolder / f'tablelog_{obj}'
# Make folder if not available
objFolder.mkdir(parents=True, exist_ok=True)
# Read the spectrum
wave, data, hdrs = sr.import_fits_data(fits_address, instrument='SDSS')
flux = data['flux'] * normFlux
z_i = hdrs[1]["z"][0]
# Measure the emission lines
lm = sr.LineMesurer(wave, flux, redshift=z_i, normFlux=normFlux)
# if local_mask.is_file():
# objMaskDF = sr.lineslogFile_to_DF(local_mask)
# for i, lineLabel in enumerate(objMaskDF.index.values):
# wave_regions = objMaskDF.loc[lineLabel, 'w1':'w6'].values
# try:
# lm.fit_from_wavelengths(lineLabel, wave_regions)
# except:
# print(f'- Failure at: {lineLabel}')
#
# # Check Extinction
]
# Analyse the spectrum
for i, file_address in enumerate(addressList):
print(f'- Treating: {file_address}')
# Open lineslog
linesLogAddress = str(file_address).replace('.fits',
'_treatedlinesLog.txt')
tableLogAddress = str(file_address).replace('.fits', '_treatedlinesLog')
figureLogAddress = str(file_address).replace('.fits',
'_treatedlinesLog.png')
# Set and crop the wavelength
wave_rest, flux, header = sr.import_fits_data(file_address,
instrument='SDSS')
idx_wave = (wave_rest >= obsData['sample_data']['wmin_array']) & (
wave_rest <= obsData['sample_data']['wmax_array'])
# Load line measurer object
lm = sr.LineMesurer(wave_rest[idx_wave],
flux[idx_wave] / fluxNorm,
linesDF_address=linesLogAddress)
pdf = PdfPrinter()
# Measure line fluxes
idcs_lines = ~lm.linesDF.index.str.contains('_b')
obsLines = lm.linesDF.loc[idcs_lines].index.values
pdf.create_pdfDoc(tableLogAddress, pdf_type='table')
pdf.pdf_insert_table(tableHeaders)
for i, obj in enumerate(objList):
print(f'\n-- Treating: {obj}{ext}.fits')
# Declare input files
objFolder = resultsFolder / f'{obj}'
fits_file = dataFolder / f'{obj}_{ext}.fits'
objMask = dataFolder / f'{obj}_{ext}_mask.txt'
results_file = objFolder / f'{obj}_{ext}_measurements.txt'
lineLog_file = objFolder / f'{obj}_{ext}_linesLog_it3.txt'
# output spectrum
spectrum_ssp = objFolder / f'{obj}_starlight_spectrum.txt'
# Load the data
wave, flux_array, header = sr.import_fits_data(fits_file,
instrument='OSIRIS')
flux = flux_array[idx_band][0] if ext in ('_B', '_R') else flux_array
lm = sr.LineMesurer(wave,
flux,
redshift=z_array[i],
crop_waves=(wmin_array[i], wmax_array[i]))
linesDF = sr.lineslogFile_to_DF(lineLog_file)
# Add new masks
linesDF = sr.lineslogFile_to_DF(lineLog_file)
ini_mask, end_points = obsData[obj]['ini_mask_array'], obsData[obj][
'end_mask_array']
labels = ['cont_mask_' + str(int(x)) for x in ini_mask]
for j, label_mask in enumerate(labels):
linesDF.loc[labels[j], ['w3', 'w4']] = ini_mask[j], end_points[j]
# Import the observation data
obsData = sr.loadConfData(
'../../../papers/gtc_greenpeas/gtc_greenpeas_data.ini',
group_variables=False)
linesFile = Path(
'D:/Pycharm Projects/spectra-synthesizer/src/specsiser/literature_data/lines_data.xlsx'
)
data_folder = Path(obsData['file_information']['data_folder'])
file_list = obsData['file_information']['files_list']
addressList = list(data_folder / file for file in file_list)
# Analyse the spectrum
for i, file_address in enumerate(addressList):
# Get fits data
wave, flux, header = sr.import_fits_data(file_address, instrument='OSIRIS')
z_mean = obsData['sample_data']['z_array'][i]
wmin_array, wmax_array = obsData['sample_data']['wmin_array'], obsData[
'sample_data']['wmax_array']
# Define wave and flux ranges
wave_rest = wave / (1 + z_mean)
idx_wave = (wave_rest >= wmin_array[i]) & (wave_rest <= wmax_array[i])
# Open lineslog
fitsFolder, fitsFile = file_address.parent, file_address.name
logFolder, logFile = fitsFolder / 'pre_analysis', fitsFile.replace(
'.fits', '_rawlinesLog.txt')
# Load line measurer object
lm = sr.LineMesurer(wave_rest[idx_wave], flux[idx_wave],
import numpy as np
import src.specsiser as sr
from pathlib import Path
from astropy import units as u
import pysynphot as pys
import matplotlib.pyplot as plt
def specPerAngs_to_specPerHz(spec_flux):
return
# Original spectrum from xshooter
fitsFileAddress = Path('D:/Downloads/ADP.2019-02-11T15_41_46.691.fits')
wave_nm, flux_array, headers = sr.import_fits_data(fitsFileAddress, instrument='xshooter')
wave_nm_pysyn, flux_array_pysyn, headers_pysyn = sr.import_fits_data(fitsFileAddress, instrument='xshooter')
# Wavelength conversion to angstroms
wave, flux = wave_nm * 10, flux_array[1]
wave_pysyn, flux_pysyn =wave_nm_pysyn * 10, flux_array_pysyn[1]
# Conversion from gemini page
fitsFileAddress_gemini = Path('D:/Downloads/ADP.2019-02-11T15_41_46.691_conversion.txt')
wave_gem, flux_gemn = np.loadtxt(fitsFileAddress_gemini, unpack=True)
# ---- Using pysynphot
spec = pys.spectrum.ArraySourceSpectrum(wave=wave_pysyn, flux=flux_pysyn, waveunits='angstroms', fluxunits='flam',
keepneg=True)
spec.convert('mjy')
spec.convert('micron')
# Manual conversion
wave_nm
conf_file_address = '../sampleHeII.ini'
obsData = sr.loadConfData(conf_file_address)
dataFolder = pathlib.Path(obsData['data_location']['data_folder'])
treatmentFolder = pathlib.Path(obsData['data_location']['treatment_folder'])
resultsFolder = pathlib.Path(obsData['data_location']['results_folder'])
sampleFiles = tuple(dataFolder.iterdir())
sampleObj = tuple([x.name[x.name.find('-')+1:x.name.find('-')+8] for x in sampleFiles])
normFlux = obsData['sample_data']['norm_flux']
for i, obj in enumerate(sampleObj):
# Load the data
wave, data, hdrs = sr.import_fits_data(sampleFiles[i], instrument='SDSS')
flux = data['flux'] * normFlux
z_i = hdrs[1]["z"][0]
#Output files
specPlotAddress = f'{obj}_SDSS_spectrum.png'
print(f'\nGalaxy {obj}')
lineLabels = ['He_II 4685', 'H_beta', 'H_alpha', '[O_III] 4959', '[O_III] 5007']
lineWaves = [4685.0, 4861.0, 5007]
for lineRef in lineLabels:
idx_line = np.where(hdrs[2]['LINENAME'] == lineRef)[0][0]
lineArea, lineAreaErr = hdrs[2]['LINEAREA'][idx_line], hdrs[2]['LINEAREA_ERR'][idx_line]
print(f'{lineRef} linea area : {lineArea:.2f}+/-{lineAreaErr:.2f}')
lm = sr.LineMesurer(wave, flux, redshift=z_i, normFlux=normFlux, crop_waves=(1+z_i) * np.array([4685-100, 5100]))
import pandas as pd
import src.specsiser as sr
from pathlib import Path
import matplotlib.pyplot as plt
conf_file_address = 'gtc_greenpeas_data.ini'
obsData = sr.loadConfData(conf_file_address, objList_check=True, group_variables=False)
dataFolder = Path(obsData['file_information']['data_folder'])
files_dict = dict(spec_mio = dataFolder/'gp004054_BR.fits',
spec_ric = dataFolder/'GP004054_comb_new_clean.fits',
spec_ric_resf = dataFolder/'GP004054_comb_new_rf_clean.fits')
z = 0.283232
wave1, flux_array1, header1 = sr.import_fits_data(files_dict['spec_mio'], instrument='OSIRIS')
wave2, flux_array2, header2 = sr.import_fits_data(files_dict['spec_ric'], instrument='OSIRIS')
wave3, flux_array3, header3 = sr.import_fits_data(files_dict['spec_ric_resf'], instrument='OSIRIS')
fig, ax = plt.subplots()
ax.step(wave2 * 1/(1+z), flux_array2, label='spec_mio')
ax.step(wave3, flux_array3, label='spec_ric_resf', linestyle=':')
ax.legend()
plt.show()
ric_idx_max = np.argmax(flux_array2)
mio_idx_max = np.argmax(flux_array3)
print(flux_array2[ric_idx_max])
print(flux_array3[mio_idx_max])
print(flux_array1/flux_array2)
print((flux_array1-flux_array2).sum())
# fileList_B = obsData['file_information']['filesB_list']
# objList_R = obsData['file_information']['objectR_list']
# fileList_R = obsData['file_information']['filesR_list']
z_objs = obsData['sample_data']['z_array']
idx_band = int(obsData['file_information']['band_flux'])
for i, obj in enumerate(objList):
fileList_B = dataFolder / fileList[i].replace('_BR', '_B')
fileList_R = dataFolder / fileList[i].replace('_BR', '_R')
file_BR, file_blue, file_red = dataFolder / fileList[
i], dataFolder / fileList_B, dataFolder / fileList_R
# Set and crop the wavelength
rest_wave, flux, header = sr.import_fits_data(file_BR, instrument='OSIRIS')
rest_waveB, fluxB, headerB = sr.import_fits_data(file_blue,
instrument='OSIRIS')
rest_waveR, fluxR, headerR = sr.import_fits_data(file_red,
instrument='OSIRIS')
z = z_objs[i]
rest_wave, rest_waveB, rest_waveR = rest_wave / (1 + z), rest_waveB / (
1 + z), rest_waveR / (1 + z)
# Plot Configuration
defaultConf = STANDARD_PLOT.copy()
rcParams.update(defaultConf)
# Plot the spectra
fig = plt.figure(figsize=(16, 9))
spec = gridspec.GridSpec(ncols=2, nrows=1, width_ratios=[16, 9])
ax0 = fig.add_subplot(spec[0])
ax1 = fig.add_subplot(spec[1])
for ext in ('_BR', '_B', '_R', '_SDSS'):
# Declare files location
dataFolder = dataFolder
objFolder = resultsFolder / f'{obj}'
fits_file = f'{obj}{ext}.fits'
# Load spectrum
print(f'\n-- Treating {counter} :{fits_file}')
if ext != '_SDSS':
wave, flux_array, header = sr.import_fits_data(dataFolder /
fits_file,
instrument='OSIRIS')
flux = flux_array[idx_band][0] if ext in ('_B',
'_R') else flux_array
lm = sr.LineMesurer(wave,
flux,
redshift=z,
normFlux=flux_norm,
crop_waves=(wmin, wmax))
else:
wave, flux, header = sr.import_fits_data(dataFolder / fits_file,
instrument='SDSS')
lm = sr.LineMesurer(wave, flux, normFlux=flux_norm)
# Load line measurer object
print(f'-- Pixel width: {np.diff(lm.wave).mean()}')
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import src.specsiser as sr
import pyneb as pn
# spec_address = '/home/vital/Astro-data/Observations/IZW18_Blue_cr_f_t_w_e__test1_fglobal.fits'
#
# wave, data, header = sr.import_fits_data(spec_address, instrument='ISIS', frame_idx=0)
# norm_flux = 1e-17
# z_obj = 0.0
#
# lm = sr.LineMesurer(wave, data[0], normFlux=norm_flux, redshift=z_obj)
# lm.plot_spectrum(specLabel='IZwicky18 Blue arm ISIS spectrum')
spec_address = '/home/vital/Dropbox/Astrophysics/Seminars/LzLCS/spec-0266-51630-0100.fits'
wave, data, header = sr.import_fits_data(spec_address,
instrument='SDSS',
frame_idx=0)
norm_flux = 1e-17
z_obj = 0.0
lm = sr.LineMesurer(wave,
data['flux'] * norm_flux,
normFlux=norm_flux,
redshift=z_obj)
lm.plot_spectrum(specLabel='CGCG007-025 SLOAN spectrum')
objDF['z'] = np.nan
for szLabel, sdssLabel in lineConversion.items():
objDF[szLabel] = np.nan
objDF[f'{szLabel}_err'] = np.nan
objDF['Comment'] = 'None'
for idx, obj in enumerate(objDF.index.values):
# Object indexing
plate, mjd, fiber = objDF.iloc[idx]['plate':'fiber']
objLabel = f'{plate}-{mjd}-{fiber}'
spec_name = f'{objLabel}.fits'
output_file = fits_folder/spec_name
print(f'- Obj {idx}/{n_objs}')
with fits.open(output_file) as hdu_list:
wave, data, hdrs = sr.import_fits_data(output_file, instrument='SDSS')
dataProp = hdrs[1]
dataLines = hdrs[2]
objDF.loc[objLabel, 'z'] = dataProp['z'][0]
for szLabel, sdssLabel in lineConversion.items():
idx_line = np.where(dataLines['LINENAME'] == sdssLabel)[0][0]
objDF.loc[objLabel, szLabel] = dataLines['LINEAREA'][idx_line]
objDF.loc[objLabel, f'{szLabel}_err'] = dataLines['LINEAREA_ERR'][idx_line]
df_file = data_folder/f'AVO_dataframe.txt'
with open(df_file, 'wb') as output_file:
string_DF = objDF.to_string()
output_file.write(string_DF.encode('UTF-8'))
pdf.create_pdfDoc(sampleFolder / tableName, pdf_type='table')
pdf.pdf_insert_table(tableHeaders)
# Analyse the spectrum
for i, file_address in enumerate(addressList):
# Open lineslog
fitsFolder, fitsFile = file_address.parent, file_address.name
lineLogFolder, lineLogFile = fitsFolder/'flux_analysis', fitsFile.replace('.fits', '_linesLog.txt')
pdfLogFolder, pdfLogFile = fitsFolder / 'flux_analysis', fitsFile.replace('.fits', '_linesLog')
objName = fitsFile.replace('.fits', '')
print(f'- {i}: {objName}')
# Set and crop the wavelength
wave_rest, flux, header = sr.import_fits_data(fitsFolder/fitsFile, instrument='SDSS')
idx_wave = (wave_rest >= obsData['sample_data']['wmin_array']) & (wave_rest <= obsData['sample_data']['wmax_array'])
# Load line measurer object
lm = sr.LineMesurer(wave_rest[idx_wave], flux[idx_wave], lineLogFolder / lineLogFile, normFlux=flux_norm)
# Measure line fluxes
idcs_lines = ~lm.linesDF.index.str.contains('_b')
obsLines = lm.linesDF.loc[idcs_lines].index.values
# Equivalent width Hbeta
eqw_Hbeta, eqwErr_Hbeta = lm.linesDF.loc['H1_4861A', 'eqw'], lm.linesDF.loc['H1_4861A', 'eqw_err']
eqw_entry = r'${:0.2f}$ $\pm$ ${:0.2f}$'.format(eqw_Hbeta, eqwErr_Hbeta)
# Normalizing flux
flux_Halpha = lm.linesDF.loc['H1_6563A', 'gauss_flux']
verbose = True
for i, objName in enumerate(objRef_list):
# Input data
spec_file, sigm_file = data_folder / objfile_list[
i], data_folder / sigmafile_list[i]
# Output data
lineslog_file = results_folder / f'{objName}_linesLog.txt'
lineslog_table = results_folder / f'{objName}_flux_table'
# Load inputs
wave, flux, header = sr.import_fits_data(spec_file,
instrument='xshooter',
frame_idx=0)
wave_sigma, sigma, header_sigma = sr.import_fits_data(
sigm_file, instrument='xshooter', frame_idx=0)
lm = sr.LineMesurer(wave,
flux,
crop_waves=[wmin_array[i], wmax_array[i]],
input_err=sigma,
normFlux=norm_flux,
redshift=z_obj)
# lm.plot_spectrum(obsLinesTable=obsLinesTable, matchedLinesDF=maskLinesDF, specLabel=f'{objName}')
mask_local = data_folder / f'{objName}_mask'
mask_local_df = sr.lineslogFile_to_DF(mask_local)
from pathlib import Path
import src.specsiser as sr
# Declare the data location
obsFitsFile = Path('./sample_data/gp121903_BR.fits')
lineMaskFile = Path('./sample_data/gp121903_BR_mask.txt')
cfgFile = Path('./sample_data/gtc_greenpeas_data.ini')
# Load the data
obsConf = sr.loadConfData(cfgFile, objList_check=True, group_variables=False)
maskDF = sr.lineslogFile_to_DF(lineMaskFile)
wave, flux, header = sr.import_fits_data(obsFitsFile, instrument='OSIRIS')
user_conf = obsConf['gp121903_line_fitting']
# Declare line measuring object
lm = sr.LineMesurer(wave,
flux,
redshift=obsConf['sample_data']['z_array'][2],
normFlux=obsConf['sample_data']['norm_flux'])
lm.plot_spectrum()
# Find lines
norm_spec = lm.continuum_remover(
noiseRegionLims=obsConf['sample_data']['noiseRegion_array'])
obsLinesTable = lm.line_finder(
norm_spec,
noiseWaveLim=obsConf['sample_data']['noiseRegion_array'],
intLineThreshold=3)
matchedDF = lm.match_lines(obsLinesTable, maskDF)
lm.plot_spectrum(obsLinesTable=obsLinesTable,
matchedLinesDF=matchedDF,
for i, obj in enumerate(objList):
print(f'\n- Treating {i} :{obj}_{ext}.fits')
# Declare input files
objFolder = resultsFolder / f'{obj}'
fits_file = dataFolder / f'{obj}_{ext}.fits'
objMask = dataFolder / f'{obj}_{ext}_mask.txt' # Declare input files
# Declare output files
lineLog_file = objFolder / f'{obj}_{ext}_linesLog_{cycle}.txt'
lineGrid_file = objFolder / f'{obj}_{ext}_lineGrid_{cycle}.png'
# Load data
wave, flux_dict, header = sr.import_fits_data(fits_file, instrument='SDSS')
flux, err = flux_dict['flux'], flux_dict['ivar']
maskDF = pd.read_csv(objMask, delim_whitespace=True, header=0, index_col=0)
# Create line measurer object
lm = sr.LineMesurer(wave,
flux,
redshift=z_objs[i],
normFlux=flux_norm,
crop_waves=(wmin_array[i], wmax_array[i]))
# lm.plot_spectrum_components(matchedLinesDF=maskDF)
# # Fit and check the regions
obsLines = maskDF.index.values
for j, lineLabel in enumerate(obsLines):
print(obj)
if i == 5:
# Declare input files
objFolder = resultsFolder / f'{obj}'
results_file = objFolder / f'{obj}_{ext}_measurements.txt'
fits_file = dataFolder / f'{obj}_{ext}.fits'
ext_fit = '1D'
fado_file = f'{obj}_FD.cxt.FADO_{ext_fit}.fits'
previousCycle = cycle.replace('3', '2')
stellarFluxFile = objFolder / f'{obj}_{ext}_stellarFlux_{previousCycle}.txt'
nebCompFile = objFolder / f'{obj}_{ext}_nebFlux_{previousCycle}.txt'
# Load Fado data
data, header = sr.import_fits_data(papaderos_fittings_folder /
fado_file,
instrument=None,
frame_idx=0)
wave_fado = np.arange(start=int(header['LAMBDA_I']),
stop=int(header['LAMBDA_F']) + 1)
normF_fado = np.power(10, header["FLUXUNIT"]) * header["GALSNORM"]
# Load observed spectrm
wave, flux_array, header = sr.import_fits_data(fits_file,
instrument='OSIRIS')
flux = flux_array[idx_band][0] if ext in ('_B', '_R') else flux_array
wave_star, flux_star = np.loadtxt(stellarFluxFile, unpack=True)
lm = sr.LineMesurer(wave,
flux,
redshift=z_objs[i],
normFlux=normF_fado,
crop_waves=(wmin_array[i], wmax_array[i]))
obsData = sr.loadConfData(conf_file_address, group_variables=False)
fits_1 = 'cgcg007025_HBIN024_FDres2_2DnebSED.fits'
fits_2 = 'cgcg007025_HBIN024_FDres2_2DnoNEB.fits'
fits_3 = 'cgcg007025_HBIN024_FDres2_3DnebSED.fits'
fits_4 = 'cgcg007025_HBIN024_FDres2_3DnoNEB.fits'
fits_5 = 'cgcg007025_HBIN024_FDres2_3DOBS.fits'
fits_6 = 'cgcg007025_HBIN024_FDres2_3DstelFIT.fits'
fits_7 = 'cgcg007025_HBIN024_FDres2_2DnebSED.fits'
fits_8 = 'red_cgcg007025_3D_SLres_HBIN024_RY.fits'
fits_9 = 'red_cgcg007025_HBIN024_FDres2.fits'
coord = (170, 170)
file_path = Path(r'S:\Astro_data\Observations\MUSE - Amorin\CGCG007.fits')
wave, cube, header = sr.import_fits_data(file_path, instrument='MUSE')
z_obj = 0.004691
norm_flux = 1e-16
file_address, ext = fits_folder / fits_1, 0
with fits.open(file_address) as hdu_list:
data1 = hdu_list[ext].data
hdr1 = hdu_list[ext].header
file_address, ext = fits_folder / fits_2, 0
with fits.open(file_address) as hdu_list:
data2 = hdu_list[ext].data
hdr2 = hdu_list[ext].header
file_address, ext = fits_folder / fits_3, 0
with fits.open(file_address) as hdu_list:
defaultConf.update(labelsDict)
rcParams.update({})
for i, obj in enumerate(objList):
if i == 0:
# Data location
objFolder = resultsFolder
cube_address_i = fitsFolder / fileList[i]
mask_address = dataFolder / obsConf['data_location']['mask_global']
db_address = objFolder / f'{obj}_database.fits'
# Load the data
wave, data, header = sr.import_fits_data(cube_address_i,
instrument='fits-cube',
frame_idx=0)
mask_global_DF = sr.lineslogFile_to_DF(mask_address)
# Declare voxels to analyse
flux5007_image = fits.getdata(db_address,
f'{ref_flux_line}_flux',
ver=1)
flux5007_levels = np.nanpercentile(flux5007_image, percentil_array)
ion, wavelength, latexLabel = sr.label_decomposition(
ref_flux_line, scalar_output=True)
for idx_level, flux_level in enumerate(flux5007_levels):
if idx_level + 1 < len(flux5007_levels):
dict_nan_values = {}
verbose = False
idx_pair = (145, 120)
i = 0
obj = objList[i]
# Data location
cube_address = fitsFolder / fileList[i]
objFolder = resultsFolder / obj
voxelFolder = resultsFolder / obj / 'voxel_data'
db_addresss = objFolder / f'{obj}_database.fits'
# Load data
wave, cube, header = sr.import_fits_data(cube_address, instrument='MUSE')
wave_rest = wave / (1 + z_objs[i])
# Loop throught the line regions
idx_region = 2
# Fitelp dictionary
example_object = RegionParameters(
region_name='CGCG07-025',
blue_spec_file=None, #fits file path of the blue spectrum
red_spec_file=None, #fits file path of the red spectrum
blue_spec_error_file=None, #fits file path of the blue spectrum error
red_spec_error_file=None, #fits file path of the red spectrum error
scale_flux=1e20, # Scales the fluxes
center_list={'low': [3649.11211, 3661.84195, 3648.06497]
}, # Center values of the Gaussian components for each zone
import src.specsiser as sr
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
# data_folder = Path('D:/Dropbox/Astrophysics/Data/J083843/blue')
# file_name = 'combined_2d_apall.fits'
data_folder = Path('D:/Dropbox/')
file_name = 'J0838_blue_apall.fits'
wave, flux_array, header = sr.import_fits_data(data_folder / file_name,
instrument='ISIS',
frame_idx=0)
print(header)
labelsDict = {
'xlabel': r'Wavelength $(\AA)$',
'ylabel': r'Flux $(erg\,cm^{-2} s^{-1} \AA^{-1})$',
'title': f'Galaxy J083843 extracted blue arm'
}
print(np.sum(flux_array[0][0]))
# Plot spectra components
fig, ax = plt.subplots(figsize=(12, 8))
ax.plot(wave, flux_array[2][0], label='Object flux')
ax.update(labelsDict)
ax.legend()
plt.show()
import numpy as np
from pathlib import Path
import src.specsiser as sr
spec_address = Path(
'/home/vital/Dropbox/Astrophysics/Papers/gtc_greenpeas/data/gp030321_B.fits'
)
wave, flux_array, header = sr.import_fits_data(spec_address,
instrument='OSIRIS')
flux, err, normFlux = flux_array[0][0], flux_array[3][0], 1e-17
lm_osiris = sr.LineMesurer(wave, flux, input_err=err, normFlux=normFlux)
lm_osiris.plot_spectrum(continuumFlux=lm_osiris.errFlux,
log_scale=True,
axConf={'title': 'OSIRIS spectrum'})
lineWaves = np.array([5600.0, 5635.0, 5651.0, 5675.0, 5697.0, 5729.0])
lm_osiris.fit_from_wavelengths('H1_4861A', lineWaves)
lm_osiris.print_results(show_plot=True)
#
spec_address = Path(
'/home/vital/Astro-data/Observations/MUSE - Amorin/CGCG007.fits'
) #D:/Google drive/Astrophysics/Datos/MUSE - Amorin/CGCG007.fits')
wave, cube, header = sr.import_fits_data(spec_address, instrument='MUSE')
idx_j, idx_i = 171, 171
flux_voxel = cube[:, idx_j, idx_i].data.data
flux_err = cube[:, idx_j, idx_i].var.data
lm_muse = sr.LineMesurer(wave, flux_voxel, input_err=flux_err)
lm_muse.plot_spectrum(continuumFlux=lm_muse.errFlux,
log_scale=True,
axConf={'title': 'MUSE spectrum'})
lineWaves = np.array([4835.0, 4868.0, 4877.0, 4891.0, 4913.0, 4941.0])
lm_muse.fit_from_wavelengths('H1_4861A', lineWaves)
# Reading parameters from four libraries
for i, obj in enumerate(objList):
# Declare input files
objFolder = resultsFolder / f'{obj}'
results_file = objFolder / f'{obj}_{ext}_measurements.txt'
# Results container
fado_measurements = {}
for ext_fit, list_params in params_per_ext.items():
ssp_lib = f'{obj}_FD.cxt.FADO_{ext_fit}.fits'
fits_address = papaderos_fittings_folder / ssp_lib
data, header = sr.import_fits_data(fits_address,
instrument=None,
frame_idx=0)
for param in list_params:
# print(f'{param} = {header[param]}')
fado_measurements[param] = header[param]
# for param in header:
# print(f'{param} = {header[param]}')
# Store the results
section_label = f'Large_FADO_fit'
sr.parseConfDict(results_file,
fado_measurements,
section_label,
clear_section=True)
