def genEmisGrid(self, linesList, teRange, neRange): # Hbeta data H1 = pn.RecAtom('H', 1) HBeta = H1.getEmissivity(teRange, neRange, wave=4861, product=False) # Generate the emissivity grids for all the ions emis_dict = {'HBeta': HBeta} # Loop through the lines list: for i in range(len(linesList)): element, ionization, wave = linesList[i][0][:-1], linesList[i][0][ -1], linesList[i][1] line_label = '{}{}_{}A'.format(element, ionization, wave) if element in ['H', 'He']: ion = pn.RecAtom(element, ionization) if element == 'H': emis_dict[line_label] = ion.getEmissivity( teRange, neRange, wave=wave, product=False) / HBeta if element == 'He': emis_dict[line_label] = ion.getEmissivity( teRange, neRange, wave=wave, product=False) / HBeta else: ion = pn.Atom(element, ionization) emis_dict[line_label] = np.log10( ion.getEmissivity( teRange, neRange, wave=wave, product=False) / HBeta) return emis_dict
def test_line_labels(): """ This tool scans all the lines from pn.LINE_LABEL_LIST, extract the wavelength and compare with the wavelength given by the corresponding atom for the corresponding transition. Is the difference is greater than 1AA for optical or 0.1mu for IR, it prints the information """ for atom_str in pn.LINE_LABEL_LIST: try: if atom_str[0] == '3': atom = None elif atom_str[-1] == 'r': atom = pn.RecAtom(atom=atom_str) else: atom = pn.Atom(atom=atom_str) except: atom = None if atom is not None: if atom.NLevels != 0: for line in pn.LINE_LABEL_LIST[atom_str]: if line[-1] == 'm': wavelength = float(line[:-1]) * 1e4 else: wavelength = float(line[:-1]) i, j = atom.getTransition(wavelength) wave = atom.wave_Ang[i - 1, j - 1] if wave < 1e4: dif = np.abs(wavelength - wave) else: dif = np.abs(wavelength - wave) / 1e3 if dif > 1.0: print(atom, line) assert dif < 1.0
def __init__(self, atom, ion, wave_label): if not isinstance(wave_label, tuple): if isinstance(wave_label, list): wave_label = tuple(wave_label) else: wave_label = tuple([wave_label]) self.wave = wave_label self.atom = pn.RecAtom(atom, ion)
def test_HbEmissivity(max_error=5e-4): H1 = pn.RecAtom('H', 1) tem = np.array([.5, 1, 1.5, 2., 3.]) * 1e4 den = 1e2 Hb_expected = np.array([2.2e-25, 1.235e-25, 8.6e-26, 6.58e-26, 4.440e-26]) Hb_computed = H1.getEmissivity(tem, den, label='4_2') for i in range(len(tem)): assert (rel_error(H1.getEmissivity(tem[i], den, label='4_2'), Hb_expected[i]) < max_error) assert (rel_error((Hb_computed[i]), Hb_expected[i]) < max_error)
def addDiagsFromObs(self, obs): """ Add all the possible diagnostics that can be computed from an Observation object Usage: diags.addDiagsFromObs(obs) Parameter: obs an Observation object """ if not isinstance(obs, pn.Observation): pn.log_.error('The argument must be an Observation object', calling=self.calling + 'addDiagsFromObs') old_level = pn.log_.level def I(i, j): wave = atom.wave_Ang[i - 1, j - 1] corrIntens = obs.getLine(sym, spec, wave).corrIntens return corrIntens def L(wave): corrIntens = obs.getLine(sym, spec, wave).corrIntens return corrIntens def B(label): full_label = atom + '_' + label corrIntens = obs.getLine(label=full_label).corrIntens return corrIntens def S(label): full_label = atom + '_' + label + 'A' corrIntens = obs.getLine(label=full_label).corrIntens return corrIntens for label in diags_dict: atom, diag_expression, error = diags_dict[label] sym, spec, rec = parseAtom2(atom) if label == '[OII] 3727+/7325+c': try: diag_value = eval(diag_expression) except Exception as ex: pn.log_.level = old_level pn.log_.debug('Diag not valid {} {}'.format(label, diag_expression)) try: pn.log_.level = 1 diag_value = eval(diag_expression) pn.log_.level = old_level if atom not in self.atomDict: if rec == 'r': self.atomDict[atom] = pn.RecAtom(atom=sym+spec) else: self.atomDict[atom] = pn.Atom(atom=atom, NLevels=self.NLevels) self.addDiag(label) except Exception as ex: pn.log_.level = old_level pn.log_.debug('Diag not valid {} {}'.format(label, diag_expression))
def interp_caseb(flux_Hb, flux_Hg, line): temp = np.logspace(np.log10(500.), np.log10(30000.), 10000)[1:-1] den = 10. H1 = pn.RecAtom('H', 1) model_Hb = H1.getEmissivity(temp, den, 4, 2) model_Hg = H1.getEmissivity(temp, den, 5, 2) if line == 'Hd': model_line = H1.getEmissivity(temp, den, 6, 2) elif line == 'He': model_line = H1.getEmissivity(temp, den, 7, 2) else: raise Exception flux_HgHb = flux_Hg / flux_Hb model_HgHb = model_Hg / model_Hb model_lineHb = model_line / model_Hb flux_lineHb = np.interp(flux_HgHb, model_HgHb, model_lineHb) flux_line = flux_lineHb * flux_Hb return flux_line
'He1_4388A':dz.colorVector['skin'], 'He1_4438A':dz.colorVector['cyan'], 'He1_4472A':dz.colorVector['olive'], 'He1_4713A':dz.colorVector['green'], 'He1_4922A':dz.colorVector['iron'], 'He1_5016A':dz.colorVector['yellow'], 'He1_5876A':dz.colorVector['orangish'], 'He1_6678A':dz.colorVector['dark blue'], 'He1_7065A':'black', 'He1_7281A':'#CC79A7'} #Atomic dictionaries pn.atomicData.setDataFile('s_iii_coll_HRS12.dat') O3 = pn.Atom('O', 3) S3 = pn.Atom('S', 3) N2 = pn.Atom('N', 2) He1 = pn.RecAtom('He', 1) S3_9000_ratio = S3.getEmissivity(10000, 1000, wave = 9531) / S3.getEmissivity(10000, 1000, wave = 9069) O3_5000_ratio = O3.getEmissivity(10000, 1000, wave = 5007) / O3.getEmissivity(10000, 1000, wave = 4959) N2_6500_ratio = N2.getEmissivity(10000, 1000, wave = 6584) / N2.getEmissivity(10000, 1000, wave = 6548) # plot_helium_relation(catalogue_df, element = 'Helium', color = '#bcbd22', label = 'Helium abundance per line') # plot_metallic_relation(catalogue_df, ['O3_5007A', 'O3_4959A'], O3_5000_ratio, 'Oxygen', color='#009E73', label = r'Oxygen $\frac{[OIII]50007\AA}{[OIII]4959\AA}$') plot_metallic_relation(catalogue_df, ['S3_9531A', 'S3_9069A'], S3_9000_ratio, 'Sulfur', color='#D55E00', label = r'Sulfur $\frac{[SIII]9531\AA}{[SIII]9069\AA}$') # plot_metallic_relation(catalogue_df, ['N2_6584A', 'N2_6548A'], N2_6500_ratio, 'Nitrogen', color='#0072B2', label = r'Oxygen $\frac{[NII]6584\AA}{[NII]6548\AA}$') dz.display_fig() print 'Data treated'
def get_continuum(self, tem, den, He1_H=0., He2_H=0., wl=np.array([3500, 3600, 3700, 3800, 3900]), cont_HI=True, cont_HeI=True, cont_HeII=True, cont_2p=True, cont_ff=True, HI_label='11_2'): """ Type of continuum to take into acount defined a boolean, defaults are True Parameters: tem: temperature [K]. May be a float or an iterable. den: density [cm-3]. May be a float or an iterable. If iterable, must have same size than tem. He1_H (float): He+/H+ abundance. Default = 0.0 He2_H (float): He++/H+ abundances. Default = 0.0 wl (np.array): Wavelengths Default = np.array([3500, 3600, 3700, 3800, 3900]) cont_HI (bool): using B. Ercolano 2006 data. Default: True cont_HeI (bool): using B. Ercolano 2006 data. Default: True cont_HeII (bool): using B. Ercolano 2006 data. Default: True cont_2p (bool): 2 photons, using D. Pequignot fit to Osterbrock. Default: True cont_ff (bool): from Storey & Hummer 1991. Default: True HI_label (str): HI label to normalize the continuum. If None, no normalization is done. Default: '11_2' Returns: The resulting continuum. Unit [A-1] if normalized, [erg/s.cm3/A] otherwise Exemple of use: C = pn.Continuum() wl = np.arange(3500, 4000, 1) cont = C.get_continuum(tem=1e4, den=1e2, He1_H=0.08, He2_H=0.02, wl=wl) plt.plot(wl, cont) """ try: _ = (e for e in tem) T_iterable = True try: _ = (e for e in den) except: den = np.ones_like(tem) * den try: _ = (e for e in He1_H) except: He1_H = np.ones_like(tem) * He1_H try: _ = (e for e in He2_H) except: He2_H = np.ones_like(tem) * He2_H except TypeError: T_iterable = False if HI_label is None: norm = 1.0 else: if self.HI is None: self.HI = pn.RecAtom('H', 1) norm = self.HI.getEmissivity(tem, den, label=HI_label, product=False) if T_iterable: cont = np.array( list( map( lambda t, d, He1_H_1, He2_H_1: self._get_continuum1( t, d, He1_H=He1_H_1, He2_H=He2_H_1, wl=wl, cont_HI=cont_HI, cont_HeI=cont_HeI, cont_HeII=cont_HeII, cont_2p=cont_2p, cont_ff=cont_ff), tem, den, He1_H, He2_H))).T return cont.squeeze() / norm else: cont = self._get_continuum1(tem, den, He1_H=He1_H, He2_H=He2_H, wl=wl, cont_HI=cont_HI, cont_HeI=cont_HeI, cont_HeII=cont_HeII, cont_2p=cont_2p, cont_ff=cont_ff) return cont / norm
# Declare data and files location obsConf = sr.loadConfData('J0838_cubes.ini') fitsFolder = Path(obsConf['data_location']['fits_folder']) dataFolder = Path(obsConf['data_location']['data_folder']) resultsFolder = Path(obsConf['data_location']['results_folder']) fileList = obsConf['data_location']['file_list'] objList = obsConf['data_location']['object_list'] z_list = obsConf['sample_data']['z_array'] norm_flux = obsConf['sample_data']['norm_flux'] percentil_array = obsConf['sample_data']['percentil_array'] voxel_grid_size = obsConf['sample_data']['grid_shape_array'] # Store emissivity ratios at standard conditions H1 = pn.RecAtom('H', 1) temp, den = 10000.0, 100.0 theoEmis_dict = {} for chemLabel, plotLabel in label_Conver.items(): ion, wave, latexLabel = sr.label_decomposition(chemLabel, scalar_output=True) dict_label = f'{plotLabel}/Hdelta' theoRatio = H1.getEmissivity(temp, den, wave=wave) / H1.getEmissivity( temp, den, wave=4102) theoEmis_dict[dict_label] = theoRatio red_model = sr.ExtinctionModel(Rv=obsConf['extinction']['R_v'], red_curve=obsConf['extinction']['red_law']) # Data location objFolder = resultsFolder
def getIonAb(obs_file, Ne_O2, Ne_Ar4, T_N2, T_O3, printIonAb = True): ### General settings # define an Observation object and assign it to name 'obs' obs = pn.Observation() # fill obs with data read from file obs_data, with lines varying across rows and a default percent error on line intensities obs.readData(obs_file, fileFormat='lines_in_rows', err_default=0.05, corrected=True) if 'H1_4.1m' in obs.lineLabels: temp = 14000 dens = 10**3.5 # Compute theoretical H5-4/Hbeta ratio from Hummer and Storey # Instatiate the H1 recombination atom H1 = pn.RecAtom('H', 1) IR2Opt_theo = H1.getEmissivity(temp, dens, label='5_4') / H1.getEmissivity(temp, dens, label='4_2') IR2Opt_obs = obs.getLine(label='H1_4.1m').corrIntens / obs.getLine(label='H1_4861A').corrIntens for line in obs.lines: if line.label[-1] == 'm': line.corrIntens *= IR2Opt_theo/IR2Opt_obs # instanciation of all the needed Atom objects all_atoms = pn.getAtomDict(atom_list=obs.getUniqueAtoms()) # define a dictionnary for the ionic abundances ab_dic = {} # we use the following lines to determine the ionic abundances ab_labels = ['C3_1907A', 'C3_1909A', 'N2_6583A', 'N3_57.4m', 'N4_1487A', 'O2_3726A', 'O2_3729A', 'O3_5007A', 'O4_25.9m', 'S2_6731A', 'S3_9069A', 'S4_10.5m', 'Ar3_7136A', 'Ar4_4740A', 'Ar5_7006A', 'Ar6_4.5m', 'Ne2_12.8m', 'Ne3_3869A', 'Ne5_3426A', 'Ne6_7.6m', 'Cl3_5518A', 'Cl3_5538A', 'Cl4_5323A', 'Mg4_4.5m', 'Mg5_5.6m'] # loop on the observed lines to determine the corresponding ionic abundances for line in obs.getSortedLines(): # this is one way to define temp and dens in each zone # must be adapted to each case if (line.atom in all_atoms) and (line.label in ab_labels): IP_cut = 30. # if IP[line.atom] > IP_cut: temp = T_O3 dens = Ne_Ar4 IP_used = 'H' else: temp = T_N2 dens = Ne_O2 IP_used = 'L' ab = all_atoms[line.atom].getIonAbundance(line.corrIntens, temp, dens, to_eval=line.to_eval, Hbeta=100) if printIonAb: print('{0:13s} {1} '.format(line.label, IP_used) + ' '.join(['{0:>8.4f}'.format(t) for t in ab * 1e6])) if line.atom not in ab_dic: ab_dic[line.atom] = [] ab_dic[line.atom].append(ab) He1 = pn.RecAtom('He', 1) He2 = pn.RecAtom('He', 2) ab_dic['He2']= He1.getIonAbundance(obs.getLine(label='He1_5876A').corrIntens, T_N2, Ne_O2, wave=5876.0) ab_dic['He3'] = He2.getIonAbundance(obs.getLine(label='He2_4686A').corrIntens, T_O3, Ne_Ar4, lev_i= 4, lev_j= 3) for atom in ab_dic: mean = np.mean(np.asarray(ab_dic[atom])) ab_dic[atom] = mean for ion in np.sort(ab_dic.keys()): if printIonAb: print('{0} = {1:.3}'.format(ion, np.log10(ab_dic[ion])+12)) return ab_dic
def compute_cHbeta(line_df, reddening_curve, R_v, temp=10000.0, den=100.0, ref_wave='H1_4861A', compMode='auto'): assert ref_wave in line_df.index, f'- ERROR: Reference line {ref_wave} is not in input dataframe index' # Create hydrogen recombination atom for emissivities calculation H1 = pn.RecAtom('H', 1) # Use all the lines from the input data frame line_labels = line_df.index.values ion_ref, waves_ref, latexLabels_ref = label_decomposition( ref_wave, scalar_output=True) ion_array, waves_array, latexLabels_array = label_decomposition( line_labels) # Mode 1: Distinguish between single (intg_flux) and blended (gauss_flux) lines if compMode == 'auto': Href_flux, Href_err = line_df.loc[ref_wave, 'intg_flux'], line_df.loc[ref_wave, 'intg_err'] obsFlux, obsErr = np.empty(line_labels.size), np.empty( line_labels.size) idcs_intg = (line_df.blended == 'None') obsFlux[idcs_intg], obsErr[idcs_intg] = line_df.loc[ idcs_intg, ['intg_flux', 'intg_err']].values obsFlux[~idcs_intg], obsErr[~idcs_intg] = line_df.loc[ ~idcs_intg, ['gauss_flux', 'gauss_err']].values # Mode 2: Use always the gaussian flux elif compMode == 'gauss': Href_flux, Href_err = line_df.loc[ref_wave, 'gauss_flux'], line_df.loc[ ref_wave, 'gauss_err'] obsFlux, obsErr = line_df['gauss_flux'].values, line_df[ 'gauss_err'].values # Ratio propagating the uncertainty between the lines obsFlux_norm = obsFlux / Href_flux obsErr_norm = obsFlux_norm * np.sqrt( np.square(obsErr / obsFlux) + np.square(Href_err / Href_flux)) assert not np.any( np.isnan(obsFlux) ) in obsFlux, '- ERROR: nan entry in input fluxes for c(Hbeta) calculation' assert not np.any( np.isnan(obsErr) ) in obsErr, '- ERROR: nan entry in input uncertainties for c(Hbeta) calculation' # Theoretical ratios refEmis = H1.getEmissivity(tem=temp, den=den, wave=waves_ref) emisIterable = (H1.getEmissivity(tem=temp, den=den, wave=wave) for wave in waves_array) linesEmis = np.fromiter(emisIterable, float) theoRatios = linesEmis / refEmis # Reddening law rc = pn.RedCorr(R_V=R_v, law=reddening_curve) Xx_ref, Xx = rc.X(waves_ref), rc.X(waves_array) f_lines = Xx / Xx_ref - 1 f_ref = Xx_ref / Xx_ref - 1 # cHbeta slope fit axes x_fred = f_lines - f_ref y_flux = np.log10(theoRatios) - np.log10(obsFlux_norm) y_err = (obsErr_norm / obsFlux_norm) * (1.0 / np.log(10)) # Perform fit lineModel = LinearModel() pars = lineModel.make_params(intercept=y_flux.min(), slope=0) output = lineModel.fit(y_flux, pars, x=x_fred, weights=1 / np.sqrt(y_err)) cHbeta, cHbeta_err = output.params['slope'].value, output.params[ 'slope'].stderr intercept, intercept_err = output.params['intercept'].value, output.params[ 'intercept'].stderr # Store the results output_dict = dict(cHbeta=cHbeta, cHbeta_err=cHbeta_err, intercept=intercept, intercept_err=intercept_err, obsRecomb=obsFlux_norm, obsRecombErr=obsErr_norm, y=y_flux, y_err=y_err, x=x_fred, line_labels=latexLabels_array, ref_line=latexLabels_ref) return output_dict
def cHbeta_from_log(self, line_df, line_labels='all', temp=10000.0, den=100.0, ref_wave='H1_4861A', comp_mode='auto', plot_address=False): # Use all hydrogen lines if none are defined if line_labels == 'all': idcs_H1 = line_df.ion == 'H1' line_labels = line_df.loc[idcs_H1].index.values assert line_labels.size > 0, f'- ERROR: No H1 ion transition lines were found in log. Check dataframe data.' # Loop through the input lines assert ref_wave in line_df.index, f'- ERROR: {ref_wave} not found in input lines log dataframe for c(Hbeta) calculation' # Label the lines which are found in the lines log idcs_lines = line_df.index.isin(line_labels) & (line_df.intg_flux > 0) & (line_df.gauss_flux > 0) line_labels = line_df.loc[idcs_lines].index.values ion_ref, waves_ref, latexLabels_ref = label_decomposition(ref_wave, scalar_output=True) ion_array, waves_array, latexLabels_array = label_decomposition(line_labels) # Observed ratios if comp_mode == 'auto': Href_flux, Href_err = line_df.loc[ref_wave, 'intg_flux'], line_df.loc[ref_wave, 'intg_err'] obsFlux, obsErr = np.empty(line_labels.size), np.empty(line_labels.size) slice_df = line_df.loc[idcs_lines] idcs_intg = slice_df.blended_label == 'None' obsFlux[idcs_intg] = slice_df.loc[idcs_intg, 'intg_flux'].values obsErr[idcs_intg] = slice_df.loc[idcs_intg, 'intg_err'].values obsFlux[~idcs_intg] = slice_df.loc[~idcs_intg, 'gauss_flux'].values obsErr[~idcs_intg] = slice_df.loc[~idcs_intg, 'gauss_err'].values obsRatio_uarray = unumpy.uarray(obsFlux, obsErr) / ufloat(Href_flux, Href_err) # TODO unumpy this with your own model elif comp_mode == 'gauss': Href_flux, Href_err = line_df.loc[ref_wave, 'gauss_flux'], line_df.loc[ref_wave, 'gauss_err'] obsFlux, obsErr = line_df.loc[idcs_lines, 'gauss_flux'], line_df.loc[idcs_lines, 'gauss_err'] obsRatio_uarray = unumpy.uarray(obsFlux, obsErr) / ufloat(Href_flux, Href_err) else: Href_flux, Href_err = line_df.loc[ref_wave, 'intg_flux'], line_df.loc[ref_wave, 'intg_err'] obsFlux, obsErr = line_df.loc[idcs_lines, 'intg_flux'], line_df.loc[idcs_lines, 'intg_err'] obsRatio_uarray = unumpy.uarray(obsFlux, obsErr) / ufloat(Href_flux, Href_err) assert not np.any(np.isnan(obsFlux)) in obsFlux, '- ERROR: nan entry in input fluxes for c(Hbeta) calculation' assert not np.any(np.isnan(obsErr)) in obsErr, '- ERROR: nan entry in input uncertainties for c(Hbeta) calculation' # Theoretical ratios H1 = pn.RecAtom('H', 1) refEmis = H1.getEmissivity(tem=temp, den=den, wave=waves_ref) emisIterable = (H1.getEmissivity(tem=temp, den=den, wave=wave) for wave in waves_array) linesEmis = np.fromiter(emisIterable, float) theoRatios = linesEmis / refEmis # Reddening law rc = pn.RedCorr(R_V=self.R_v, law=self.red_curve) Xx_ref, Xx = rc.X(waves_ref), rc.X(waves_array) f_lines = Xx / Xx_ref - 1 f_ref = Xx_ref / Xx_ref - 1 # cHbeta linear fit values x_values = f_lines - f_ref y_values = np.log10(theoRatios) - unumpy.log10(obsRatio_uarray) # Perform fit lineModel = LinearModel() y_nom, y_std = unumpy.nominal_values(y_values), unumpy.std_devs(y_values) pars = lineModel.make_params(intercept=y_nom.min(), slope=0) output = lineModel.fit(y_nom, pars, x=x_values, weights=1 / np.sqrt(y_std)) cHbeta, cHbeta_err = output.params['slope'].value, output.params['slope'].stderr intercept, intercept_err = output.params['intercept'].value, output.params['intercept'].stderr if plot_address: STANDARD_PLOT = {'figure.figsize': (14, 7), 'axes.titlesize': 12, 'axes.labelsize': 14, 'legend.fontsize': 10, 'xtick.labelsize': 10, 'ytick.labelsize': 10} axes_dict = {'xlabel': r'$f_{\lambda} - f_{H\beta}$', 'ylabel': r'$ \left(\frac{I_{\lambda}}{I_{\H\beta}}\right)_{Theo} - \left(\frac{F_{\lambda}}{F_{\H\beta}}\right)_{Obs}$', 'title': f'Logaritmic extinction coefficient calculation'} rcParams.update(STANDARD_PLOT) fig, ax = plt.subplots(figsize=(8, 4)) fig.subplots_adjust(bottom=-0.7) # Data ratios err_points = ax.errorbar(x_values, y_nom, y_std, fmt='o') # Linear fitting linear_fit = cHbeta * x_values + intercept linear_label = r'$c(H\beta)={:.2f}\pm{:.2f}$'.format(cHbeta, cHbeta_err) ax.plot(x_values, linear_fit, linestyle='--', label=linear_label) ax.update(axes_dict) # Legend ax.legend(loc='best') ax.set_ylim(-0.5, 0.5) # Generate plot plt.tight_layout() if isinstance(plot_address, (str, pathlib.WindowsPath, pathlib.PosixPath)): # crs = mplcursors.cursor(ax, hover=True) # crs.connect("add", lambda sel: sel.annotation.set_text(sel.annotation)) plt.savefig(plot_address, dpi=200, bbox_inches='tight') else: mplcursors.cursor(ax).connect("add", lambda sel: sel.annotation.set_text(latexLabels_array[sel.target.index])) plt.show() return cHbeta, cHbeta_err
from CodeTools.PlottingManager import myPickle from Plotting_Libraries.dazer_plotter import Plot_Conf from numpy import linspace import seaborn as sns import pyneb as pn #Declare Classes pv = myPickle() dz = Plot_Conf() #Define figure format dz.FigConf() # Atom creation and definition of physical conditions H1 = pn.RecAtom('H',1) HeI = pn.RecAtom('He', 1) #Define physical conditions tem = 10000 tem_range = linspace(10000, 25000, 100) den = 0 den_range = linspace(0, 300, 200) # Comment the second if you want all the lines to be plotted HeI_Lines=[3889.0, 4026.0, 4471.0, 5876.0, 6678.0, 7065.0, 10830.0] print 'Emissivity', HeI.getEmissivity(tem, 1, wave=3889.0) #--------------------------Density case----------------------------------
from numpy import array, linspace, zeros, pi from CodeTools.PlottingManager import myPickle import pyneb as pn S4 = pn.RecAtom('He', 1) He1_Emis_pyneb = S4.getEmissivity(tem=10000.0, den=100.0, label='3889.0') He_Emis_article = 1.4005 * 1e-25 #Units: 4 Pi j / n_e / n_He+ (erg cm^3 s^-1). #Emissivity coefficient print 'Emissivity ratio', He1_Emis_pyneb / He_Emis_article #Load script support classes pv = myPickle() #Declare Figure format pv.FigFormat_One(ColorConf='Night1') #Load pyneb atom H1 = pn.RecAtom('H', 1) S4 = pn.RecAtom('He', 1) Helium_Labels = ['3889.0', '4026.0', '4471.0', '5876.0', '6678.0', '7065.0'] #Declare initial conditions Te_vector = linspace(8000, 25000, 100) #K ne_vector = linspace(10, 1000, 100) #cm^-3 Te_0 = 10000 ne_0 = 100
import pyneb as pn import numpy as np import src.specsiser as sr def corO2_7319(emis_ratio, cHbeta, flambda, O2_abund, O3_abund, Te_high): fluxCorr = np.power(10, O2_abund + emis_ratio - flambda * cHbeta - 12) + \ np.power(10, O3_abund + 0.9712758487381 + np.log10(np.power(Te_high/10000.0, 0.44)) - flambda * cHbeta - 12) return fluxCorr Te, ne = 10000.0, 100.0 cHbeta = 0.255 H1_ion = pn.RecAtom('H', 1) O2_ion = pn.Atom('O', 2) O3_ion = pn.Atom('O', 3) cHbeta = 0.12 flambda = -0.55 O2_abund = 0.00000648 O3_abund = 0.00004578 logO2abund = 12 + np.log10(O2_abund) logO3abund = 12 + np.log10(O3_abund) Hbeta_emis = H1_ion.getEmissivity(tem=Te, den=ne, wave=4861) O2_emis = (O2_ion.getEmissivity(tem=Te, den=ne, wave=7319) + O2_ion.getEmissivity(tem=Te, den=ne, wave=7319)) / Hbeta_emis logO2_emis = np.log10(O2_emis)
S2 = pn.Atom('S', 2) #S2.printIonic() S2_6718 = AIR(1 / (S2.getEnergy(S2.getTransition(6718)[0]) - S2.getEnergy(S2.getTransition(6718)[1]))) S2_6732 = AIR(1 / (S2.getEnergy(S2.getTransition(6732)[0]) - S2.getEnergy(S2.getTransition(6732)[1]))) Ar3 = pn.Atom('Ar', 3) #Ar3.printIonic() Ar3_7137 = AIR(1 / (Ar3.getEnergy(Ar3.getTransition(7137)[0]) - Ar3.getEnergy(Ar3.getTransition(7137)[1]))) # Wavelengths from pyNeb RecAtoms are in A in Air like the SDSS spectra. Conversion needed. H1 = pn.RecAtom('H', 1) # Hydrogen Balmer series H1_3970 = H1.getWave(7, 2) H1_4102 = H1.getWave(6, 2) H1_4341 = H1.getWave(5, 2) H1_4862 = H1.getWave(4, 2) H1_6564 = H1.getWave(3, 2) H1 = pn.RecAtom('H', 1) # Hydrogen Lyman series H1_1216 = H1.getWave(2, 1) He1 = pn.RecAtom('He', 1) # Helium He2 = pn.RecAtom('He', 2) # Helium He2_4686 = He2.getWave(4, 3) He2_5411 = He2.getWave(7, 4)
# The_Ratio = Abund * Line_dict['10.51m'] / Line_dict['4861.36A'] # S3_abund_pyneb = S4.getIonAbundance(int_ratio = The_Ratio, tem = Te_test, den = ne_test, wave = 105000, Hbeta = 1) # Abun_formula = log10(The_Ratio) + 6.3956 + 0.0416/t4_test - 0.4216 * log10(t4_test) - 12 # Emis_formula = 12 + p_1[0] + p_1[1]/t4_range + p_1[2] * log10(t4_range) # print 'Comparing abund', S3_abund_pyneb, 10**Abun_formula # # # #Display figure # dz.display_fig() #--------------------------------Helium I Lines-------------------------------- #The formula has the shape: E_HeII / E_Hbeta = A * t_4 ^ B HI = pn.RecAtom('H', 1) He1 = pn.RecAtom('He', 1) A_0 = 1 / 2.04 B_0 = - 0.13 C_0 = 1 / 0.783 D_0 = - 0.23 E_0 = 1 / 2.58 F_0 = - 0.25 # #Declare Classes # dz = Plot_Conf() # # #Define figure format
def intrinsic_ratios(t0, n0, r_type='HaHb', product=False, silent=True, verbose=False): ''' Function to obtain Ha/Hb, Hg/Hb, or Hd/Hb flux ratios Parameters ---------- t0 : array like Array of electron temperatures in units of K n0 : array like Array of electron densities in units of cm^-3 r_type : string 'HaHb', 'HgHb', or 'HdHb' to indicate which line ratio to calculate product : boolean If True, all the combination of (t0, n0) are used. If False (default), t0 and n0 must have the same size and are joined. silent : boolean Turns off stdout messages. Default: True verbose : boolean Turns on additional stdout messages. Default: False Returns ------- ratio0 : float or array like Intrinsic Balmer decrement ratios, Ha/Hb, Hg/Hb, Hd/Hb recFitsFile : string Name of FITS file containing recombination coefficients Notes ----- Created by Chun Ly, 21 November 2016 Modified by Chun Ly, 22 November 2016 - Previously called HaHb() function - Fix to allow for other balmer decrement options ''' if silent == False: print '### Begin balmer_decrement.intrinsic_ratios | '+systime() # + on 22/11/2016 if r_type != 'HaHb' and r_type != 'HgHb' and r_type != 'HdHb': print "Invalid [r_type]" print "Options are 'HaHb', 'HgHb', 'HdHb'" print "Exiting!!!" return #endif H1 = pn.RecAtom('H', 1) if silent == False: print '### Using the following atomic data' print H1.recFitsFullPath Hbeta = H1.getEmissivity(tem=t0, den=n0, lev_i=4, lev_j=2, product=product) # Mod on 22/11/2016 if r_type == 'HaHb': Halpha = H1.getEmissivity(tem=t0, den=n0, lev_i=3, lev_j=2, product=product) ratio0 = Halpha/Hbeta if r_type == 'HgHb': Hgamma = H1.getEmissivity(tem=t0, den=n0, lev_i=5, lev_j=2, product=product) ratio0 = Hgamma/Hbeta if r_type == 'HdHb': Hdelta = H1.getEmissivity(tem=t0, den=n0, lev_i=6, lev_j=2, product=product) ratio0 = Hdelta/Hbeta if silent == False: print '### End balmer_decrement.intrinsic_ratios | '+systime() return ratio0, H1.recFitsFile