def load_elements(self): #Set atomic data #atomicData.setDataFile('he_i_rec_Pal12-Pal13.fits') atomicData.setDataFile('s_iii_coll_HRS12.dat') #Default: 's_iii_atom_PKW09.dat' 'S3: All energy and A values: Podobedova, Kelleher, and Wiese 2009, J. Phys. Chem. Ref. Data, Vol.' 'S3: collision strengths: Tayal & Gupta 1999, ApJ, 526, 544' #New Atomic data s_iii_coll_HRS12.dat 'S3: All energy and A values: Podobedova, Kelleher, and Wiese 2009, J. Phys. Chem. Ref. Data, Vol.' 'S3: collision strengths: Hudson, Ramsbottom & Scott 2012, ApJ, 750, 65' #Declare ions self.S2_atom = Atom('S', 2) self.S3_atom = Atom('S', 3) self.Ar3_atom = Atom('Ar', 3) self.Ar4_atom = Atom('Ar', 4) self.N2_atom = Atom('N', 2) self.O2_atom = Atom('O', 2) self.O3_atom = Atom('O', 3) self.H1_atom = RecAtom('H', 1) self.He1_atom = RecAtom('He', 1) self.He2_atom = RecAtom('He', 2) #Pyneb objects self.diags = Diagnostics() #Ohrs 2016 relation for the OI_SI gradient self.logSI_OI_Gradient = random.normal( -1.53, 0.05, size=self.MC_array_len ) # random.normal(-1.78, 0.03, size = self.MC_array_len) self.OI_SI = power(10, -self.logSI_OI_Gradient) #Theoretical ratios self.S3_ratio = self.S3_atom.getEmissivity( 10000, 100, wave=9531) / self.S3_atom.getEmissivity( 10000, 100, wave=9069) self.S3_9000_ratio = random.normal( self.S3_atom.getEmissivity(10000, 100, wave=9531) / self.S3_atom.getEmissivity(10000, 100, wave=9069), 0.01, size=self.MC_array_len) self.N2_6000_ratio = self.N2_atom.getEmissivity( 10000, 100, wave=6584) / self.N2_atom.getEmissivity( 10000, 100, wave=6548) self.O3_5000_ratio = self.O3_atom.getEmissivity( 10000, 100, wave=5007) / self.O3_atom.getEmissivity( 10000, 100, wave=4959) #Factors to speed calculations self.lines_factors = {} self.lines_factors['S3_9069A'] = 1 + self.S3_ratio self.lines_factors['S3_9531A'] = 1 + 1 / self.S3_ratio #Cloudy models for the SIV contribution self.m_SIV_correction = random.normal(1.1628, 0.00559, size=self.MC_array_len) self.n_SIV_correction = random.normal(0.0470, 0.0097, size=self.MC_array_len) #self.m_SIV_correction = random.normal(1.109, 0.01, size = self.MC_array_len) #self.n_SIV_correction = random.normal(0.135, 0.0173, size = self.MC_array_len) #CHAOS relation TNII-TSIII #T[SIII] = 1.312(+-0.075)T[NII]-0.313(+-0.058) #TNII = (0.762+-0.044)*TSIII + 0.239+-0.046 self.m_TNII_correction = random.normal(0.762, 0.044, size=self.MC_array_len) self.n_TNII_correction = random.normal(0.239, 0.046, size=self.MC_array_len) #Truncated gaussian for the density lower_trunc, upper_trunc = (1.0 - 50.0) / 25.0, (100 - 50) / 25.0 self.Truncated_gaussian = truncnorm(lower_trunc, upper_trunc, loc=50, scale=25) print '-Elements loaded\n' return
def compare_RecombCoeffs(self, obj_data, lineslog_frame, spectral_limit=200): # Create hidrogen atom object self.H1_atom = RecAtom('H', 1) linformat_df = read_csv( '/home/vital/workspace/dazer/format/emlines_pyneb_optical_infrared.dz', index_col=0, names=['ion', 'lambda_theo', 'latex_format'], delim_whitespace=True) lineslog_frame['latex_format'] = 'none' for line in lineslog_frame.index: if '_w' not in line: # Structure to avoid wide components lineslog_frame.loc[line, 'latex_format'] = r'${}$'.format( linformat_df.loc[line, 'latex_format']) # Load electron temperature and density (if not available it will use Te = 10000K and ne = 100cm^-3) T_e = self.checking_for_ufloat(obj_data.TeSIII) if ~isnan( self.checking_for_ufloat(obj_data.TeSIII)) else 10000.0 n_e = self.checking_for_ufloat(obj_data.neSII) if ~isnan( self.checking_for_ufloat(obj_data.neSII)) else 100.0 # Get the Hidrogen recombination lines that we have observed in this object Obs_Hindx = lineslog_frame.Ion.isin(self.RecombRatios_Ions) # Calculate recombination coefficients and reddening curve values Obs_H_Emis = empty(len(Obs_Hindx)) Obs_Ions = lineslog_frame.loc[Obs_Hindx, 'Ion'].values for i in range(len(Obs_Ions)): TransitionCode = Obs_Ions[i][Obs_Ions[i].find('_') + 1:len(Obs_Ions[i])] Obs_H_Emis[i] = self.H1_atom.getEmissivity(tem=T_e, den=n_e, label=TransitionCode) # Normalize by Hbeta (this new constant is necessary to avoid a zero sigma) Hbeta_Emis = self.H1_atom.getEmissivity(tem=T_e, den=n_e, label='4_2') Fbeta_flux = ufloat( lineslog_frame.loc['H1_4861A']['line_Flux'].nominal_value, lineslog_frame.loc['H1_4861A']['line_Flux'].std_dev) # Load theoretical and observational recombination ratios to data frame lineslog_frame.loc[Obs_Hindx, 'line_Emissivity'] = Obs_H_Emis lineslog_frame.loc[Obs_Hindx, 'line_TheoRecombRatio'] = Obs_H_Emis / Hbeta_Emis lineslog_frame.loc[Obs_Hindx, 'line_ObsRecombRatio'] = lineslog_frame.loc[ Obs_Hindx, 'line_Flux'].values / Fbeta_flux # Get indeces of emissions in each arm ObsBlue_Hindx = Obs_Hindx & (lineslog_frame.lambda_theo < obj_data.join_wavelength) ObsRed_Hindx = Obs_Hindx & (lineslog_frame.lambda_theo > obj_data.join_wavelength) # Recalculate red arm coefficients so they are normalized by red arm line (the most intense) if (ObsRed_Hindx.sum() ) > 0: # Can only work if there is at least one line idx_Redmax = lineslog_frame.loc[ObsRed_Hindx]['flux_intg'].idxmax( ) # We do not use line_flux because it is a ufloat and it does not work with idxmax H_Redmax_flux = lineslog_frame.loc[idx_Redmax, 'line_Flux'] H_Redmax_emis = lineslog_frame.loc[idx_Redmax, 'line_Emissivity'] Flux_Redmax = ufloat( H_Redmax_flux.nominal_value * Hbeta_Emis / H_Redmax_emis, H_Redmax_flux.std_dev * Hbeta_Emis / H_Redmax_emis) lineslog_frame.loc[ObsRed_Hindx, 'line_ObsRecombRatio'] = lineslog_frame.loc[ ObsRed_Hindx, 'line_Flux'].values / Flux_Redmax # Load x axis values: (f_lambda - f_Hbeta) and y axis values: log(F/Fbeta)_theo - log(F/Fbeta)_obs to dataframe lineslog_frame.loc[Obs_Hindx, 'x axis values'] = lineslog_frame.loc[Obs_Hindx, 'line_f'].values - \ lineslog_frame.loc['H1_4861A']['line_f'] lineslog_frame.loc[Obs_Hindx, 'y axis values'] = unum_log10( lineslog_frame.loc[Obs_Hindx, 'line_TheoRecombRatio'].values ) - unum_log10(lineslog_frame.loc[Obs_Hindx, 'line_ObsRecombRatio'].values) # Compute all the possible configuration of points and store them output_dict = {} # --- All points: output_dict['all_x'] = lineslog_frame.loc[Obs_Hindx, 'x axis values'].values output_dict['all_y'] = lineslog_frame.loc[Obs_Hindx, 'y axis values'].values output_dict['all_ions'] = list( lineslog_frame.loc[Obs_Hindx, 'latex_format'].values) # --- By arm output_dict['blue_x'] = lineslog_frame.loc[ObsBlue_Hindx, 'x axis values'].values output_dict['blue_y'] = lineslog_frame.loc[ObsBlue_Hindx, 'y axis values'].values output_dict['blue_ions'] = list( lineslog_frame.loc[ObsBlue_Hindx, 'latex_format'].values) output_dict['red_x'] = lineslog_frame.loc[ObsRed_Hindx, 'x axis values'].values output_dict['red_y'] = lineslog_frame.loc[ObsRed_Hindx, 'y axis values'].values output_dict['red_ions'] = list( lineslog_frame.loc[ObsRed_Hindx, 'latex_format'].values) # --- Store fluxes output_dict['Blue_ObsRatio'] = unum_log10( lineslog_frame.loc[ObsBlue_Hindx, 'line_ObsRecombRatio'].values) output_dict['Red_ObsRatio'] = unum_log10( lineslog_frame.loc[ObsRed_Hindx, 'line_ObsRecombRatio'].values) output_dict['line_Flux_Blue'] = lineslog_frame.loc[ObsBlue_Hindx, 'line_Flux'].values output_dict['line_Flux_Red'] = lineslog_frame.loc[ObsRed_Hindx, 'line_Flux'].values output_dict['line_wave_Blue'] = lineslog_frame.loc[ ObsBlue_Hindx, 'lambda_theo'].values output_dict['line_wave_Red'] = lineslog_frame.loc[ObsRed_Hindx, 'lambda_theo'].values # --- Inside limits if obj_data.h_gamma_valid == 'yes': in_idcs = Obs_Hindx elif obj_data.h_gamma_valid == 'no': wave_idx = ((lineslog_frame.lambda_theo > (obj_data.Wmin_Blue + spectral_limit)) & ( lineslog_frame.lambda_theo < (obj_data.join_wavelength - spectral_limit))) \ | ((lineslog_frame.lambda_theo > (obj_data.join_wavelength + spectral_limit)) & ( lineslog_frame.lambda_theo < (obj_data.Wmax_Red - spectral_limit))) in_idcs = Obs_Hindx & wave_idx output_dict['in_x'] = lineslog_frame.loc[in_idcs, 'x axis values'].values output_dict['in_y'] = lineslog_frame.loc[in_idcs, 'y axis values'].values output_dict['in_ions'] = list( lineslog_frame.loc[in_idcs, 'latex_format'].values) # --- Outside limis if obj_data.h_gamma_valid == 'no': wave_idx = (lineslog_frame.lambda_theo < (obj_data.Wmin_Blue + spectral_limit)) | ( lineslog_frame.lambda_theo > (obj_data.Wmax_Red - spectral_limit)) out_idcs = Obs_Hindx & wave_idx output_dict['out_x'] = lineslog_frame.loc[out_idcs, 'x axis values'].values output_dict['out_y'] = lineslog_frame.loc[out_idcs, 'y axis values'].values output_dict['out_ions'] = list( lineslog_frame.loc[out_idcs, 'latex_format'].values) else: output_dict['out_x'] = None output_dict['out_y'] = None output_dict['out_ions'] = None return output_dict