def __init__(self, session, fname=None, ions=None, unique_level_identifier=None, ds_short_name="ku_latest"): self.session = session if fname is None: self.fname = GFALL_URL else: self.fname = fname self.gfall_reader = GFALLReader(ions, self.fname, unique_level_identifier) if ions is not None: try: ions = parse_selected_species(ions) except ParseException: raise ValueError( 'Input is not a valid species string {}'.format(ions)) ions = pd.DataFrame.from_records( ions, columns=["atomic_number", "ion_charge"]) self.ions = ions.set_index(['atomic_number', 'ion_charge']) else: self.ions = None self.data_source = DataSource.as_unique(self.session, short_name=ds_short_name) if self.data_source.data_source_id is None: # To get the id if a new data source was created self.session.flush()
def __init__(self, session, ions=None, ds_short_name=None): if ds_short_name is None: ds_short_name = '{}_v{}'.format(self.ds_prefix, masterlist_version) self.session = session self.ion_readers = list() self.ions = list() if ions is not None: try: ions = parse_selected_species(ions) except ParseException: raise ValueError( 'Input is not a valid species string {}'.format(ions)) self.ions = [convert_species_tuple2chianti_str(_) for _ in ions] else: self.ions = masterlist_ions for ion in self.ions: if ion in self.masterlist_ions: self.ion_readers.append(ChiantiIonReader(ion)) else: logger.info("Ion {0} is not available.".format(ion)) self.data_source = DataSource.as_unique(self.session, short_name=ds_short_name) # To get the id if a new data source was created if self.data_source.data_source_id is None: self.session.flush()
def __init__(self, session, ions=None, ds_short_name="chianti_v8.0.2"): self.session = session # ToDo write a parser for Spectral Notation self.ion_readers = list() self.ions = list() if ions is not None: try: ions = parse_selected_species(ions) except ParseException: raise ValueError( 'Input is not a valid species string {}'.format(ions)) self.ions = [convert_species_tuple2chianti_str(_) for _ in ions] else: self.ions = masterlist_ions for ion in self.ions: if ion in self.masterlist_ions: self.ion_readers.append(ChiantiIonReader(ion)) else: print("Ion {0} is not available".format(ion)) self.data_source = DataSource.as_unique(self.session, short_name=ds_short_name) if self.data_source.data_source_id is None: # To get the id if a new data source was created self.session.flush()
def __init__(self, ions, collisions=False, priority=10): """ Parameters ---------- ions : string Selected Chianti ions. collisions: bool, optional Grab collisional data, by default False. priority: int Priority of the current data source. """ self.ions = parse_selected_species(ions) self.priority = priority self._get_levels_lines(get_collisions=collisions)
def __init__(self, session, fname, ions=None, ds_short_name="ku_latest"): self.session = session self.gfall_reader = GFALLReader(fname) if ions is not None: try: ions = parse_selected_species(ions) except ParseException: raise ValueError('Input is not a valid species string {}'.format(ions)) ions = pd.DataFrame.from_records(ions, columns=["atomic_number", "ion_charge"]) self.ions = ions.set_index(['atomic_number', 'ion_charge']) else: self.ions = None self.data_source = DataSource.as_unique(self.session, short_name=ds_short_name) if self.data_source.data_source_id is None: # To get the id if a new data source was created self.session.flush()
def __init__(self, ions=None, fname=None, unique_level_identifier=None, priority=10): """ Parameters ---------- fname: str Path to the gfall file (http or local file). ions: str, optional Ions to extract, by default None. unique_level_identifier: list List of attributes to identify unique levels from. Will always use atomic_number and ion charge in addition. priority: int, optional Priority of the current data source. """ if fname is None: self.fname = GFALL_URL else: self.fname = fname self.priority = priority if ions is not None: self.ions = parse_selected_species(ions) else: self.ions = None self._gfall_raw = None self._gfall = None self._levels = None self._lines = None if unique_level_identifier is None: logger.warn( 'A specific combination to identify unique levels from ' 'GFALL data has not been given. Defaulting to ' '["energy", "j"].') self.unique_level_identifier = self.default_unique_level_identifier else: self.unique_level_identifier = unique_level_identifier
def __init__(self, gfall_reader, ionization_energies, ions, lines_loggf_threshold=-3, levels_metastable_loggf_threshold=-3): self.levels_lines_param = { "levels_metastable_loggf_threshold": levels_metastable_loggf_threshold, "lines_loggf_threshold": lines_loggf_threshold } self.ions = parse_selected_species(ions) self.gfall_reader = gfall_reader self.ionization_energies = ionization_energies.base self.ground_levels = ionization_energies.get_ground_levels() self.levels_all = self._get_all_levels_data().reset_index() self.lines_all = self._get_all_lines_data(self.levels_all) self._create_levels_lines(**self.levels_lines_param) self._create_macro_atom() self._create_macro_atom_references()
def __init__(self, ions=None, fname='http://kurucz.harvard.edu/linelists/gfall/gfall.dat', priority=10, unique_level_identifier=None): """ Parameters ---------- fname: str path to the gfall file (http or local file) ions: str, optional ions to extract, by default None unique_level_identifier: list list of attributes to identify unique levels from. Will always use atomic_number and ion charge in addition. """ self.fname = fname self.priority = priority if ions is not None: self.ions = parse_selected_species(ions) else: self.ions = None self._gfall_raw = None self._gfall = None self._levels = None self._lines = None if unique_level_identifier is None: logger.warn('A specific combination to identify unique levels from ' 'GFALL data has not been given. Defaulting to ' '["energy", "j"].') self.unique_level_identifier = self.default_unique_level_identifier else: self.unique_level_identifier = unique_level_identifier
def __init__( self, session, selected_atoms, chianti_ions=None, kurucz_short_name="ku_latest", chianti_short_name="chianti_v8.0.2", nist_short_name="nist-asd", atom_masses_max_atomic_number=30, lines_loggf_threshold=-3, levels_metastable_loggf_threshold=-3, collisions_temperatures=None, ): self.session = session # Set the parameters for the dataframes self.atom_masses_param = { "max_atomic_number": atom_masses_max_atomic_number } self.levels_lines_param = { "levels_metastable_loggf_threshold": levels_metastable_loggf_threshold, "lines_loggf_threshold": lines_loggf_threshold } if collisions_temperatures is None: collisions_temperatures = np.arange(2000, 50000, 2000) else: collisions_temperatures = np.array(collisions_temperatures, dtype=np.int64) self.collisions_param = {"temperatures": collisions_temperatures} try: self.selected_atomic_numbers = list( map(int, parse_selected_atoms(selected_atoms))) except ParseException: raise ValueError( 'Input is not a valid atoms string {}'.format(selected_atoms)) if chianti_ions is not None: # Get a list of tuples (atomic_number, ion_charge) for the chianti ions try: self.chianti_ions = parse_selected_species(chianti_ions) self.chianti_ions = [ tuple(map(int, t)) for t in self.chianti_ions ] except ParseException: raise ValueError( 'Input is not a valid species string {}'.format( chianti_ions)) try: chianti_atomic_numbers = { atomic_number for atomic_number, ion_charge in self.chianti_ions } assert chianti_atomic_numbers.issubset( set(self.selected_atomic_numbers)) except AssertionError: raise ValueError( "Chianti ions *must* be species of selected atoms!") else: self.chianti_ions = list() self._chianti_ions_table = None # Query the data sources self.ku_ds = None self.ch_ds = None self.nist_ds = None try: self.ku_ds = session.query(DataSource).filter( DataSource.short_name == kurucz_short_name).one() except NoResultFound: raise NoResultFound("Kurucz data source is not found!") try: self.nist_ds = session.query(DataSource).filter( DataSource.short_name == nist_short_name).one() except NoResultFound: raise NoResultFound("NIST ASD data source is not found!") if self.chianti_ions: try: self.ch_ds = session.query(DataSource).filter( DataSource.short_name == chianti_short_name).one() except NoResultFound: raise NoResultFound("Chianti data source is not found!") self._atom_masses = None self._ionization_energies = None self._levels = None self._lines = None self._collisions = None self._macro_atom = None self._macro_atom_references = None self._zeta_data = None
def _get_levels_lines(self, data): """ Generates `levels` and `lines` DataFrames. Parameters ---------- data : dict Dictionary containing one dictionary per specie with keys `levels` and `lines`. """ lvl_list = [] lns_list = [] for ion, parser in data.items(): atomic_number = parse_selected_species(ion)[0][0] ion_charge = parse_selected_species(ion)[0][1] lvl = parser['levels'].base # some ID's have negative values (theoretical?) lvl.loc[lvl['ID'] < 0, 'method'] = 'theor' lvl.loc[lvl['ID'] > 0, 'method'] = 'meas' lvl['ID'] = np.abs(lvl['ID']) lvl_id = lvl.set_index('ID') lvl['atomic_number'] = atomic_number lvl['ion_charge'] = ion_charge # i.e. Si I = (14,0) then `ion_charge` = 0 lvl_list.append(lvl) lns = parser['lines'].base lns = lns.set_index(['i', 'j']) lns['energy_lower'] = lvl_id['E(cm^-1)'].reindex(lns.index, level=0).values lns['energy_upper'] = lvl_id['E(cm^-1)'].reindex(lns.index, level=1).values lns['g_lower'] = lvl_id['g'].reindex(lns.index, level=0).values lns['g_upper'] = lvl_id['g'].reindex(lns.index, level=1).values lns['j_lower'] = (lns['g_lower'] - 1) / 2 lns['j_upper'] = (lns['g_upper'] - 1) / 2 lns['atomic_number'] = atomic_number lns['ion_charge'] = ion_charge lns = lns.reset_index() lns_list.append(lns) levels = pd.concat(lvl_list) levels['priority'] = self.priority levels = levels.reset_index(drop=False) levels = levels.rename(columns={ 'Configuration': 'label', 'E(cm^-1)': 'energy', 'index': 'level_index' }) levels['j'] = (levels['g'] - 1) / 2 levels = levels.set_index( ['atomic_number', 'ion_charge', 'level_index']) levels = levels[['energy', 'j', 'label', 'method', 'priority']] lines = pd.concat(lns_list) lines = lines.rename(columns={'Lam(A)': 'wavelength'}) lines['wavelength'] = u.Quantity(lines['wavelength'], u.AA).to('nm').value lines['level_index_lower'] = lines['i'] - 1 lines['level_index_upper'] = lines['j'] - 1 lines['gf'] = lines['f'] * lines['g_lower'] lines = lines.set_index([ 'atomic_number', 'ion_charge', 'level_index_lower', 'level_index_upper' ]) lines = lines[[ 'energy_lower', 'energy_upper', 'gf', 'j_lower', 'j_upper', 'wavelength' ]] self.levels = levels self.lines = lines return
def __init__(self, session, selected_atoms, chianti_ions=None, kurucz_short_name="ku_latest", chianti_short_name="chianti_v8.0.2", nist_short_name="nist-asd", atom_masses_max_atomic_number=30, lines_loggf_threshold=-3, levels_metastable_loggf_threshold=-3, collisions_temperatures=None, ): self.session = session # Set the parameters for the dataframes self.atom_masses_param = { "max_atomic_number": atom_masses_max_atomic_number } self.levels_lines_param = { "levels_metastable_loggf_threshold": levels_metastable_loggf_threshold, "lines_loggf_threshold": lines_loggf_threshold } if collisions_temperatures is None: collisions_temperatures = np.arange(2000, 50000, 2000) else: collisions_temperatures = np.array(collisions_temperatures, dtype=np.int64) self.collisions_param = { "temperatures": collisions_temperatures } try: self.selected_atomic_numbers = parse_selected_atoms(selected_atoms) except ParseException: raise ValueError('Input is not a valid atoms string {}'.format(selected_atoms)) if chianti_ions is not None: # Get a list of tuples (atomic_number, ion_charge) for the chianti ions try: self.chianti_ions = parse_selected_species(chianti_ions) except ParseException: raise ValueError('Input is not a valid species string {}'.format(chianti_ions)) try: chianti_atomic_numbers = {atomic_number for atomic_number, ion_charge in self.chianti_ions} assert chianti_atomic_numbers.issubset(set(self.selected_atomic_numbers)) except AssertionError: raise ValueError("Chianti ions *must* be species of selected atoms!") else: self.chianti_ions = list() self._chianti_ions_table = None # Query the data sources self.ku_ds = None self.ch_ds = None self.nist_ds = None try: self.ku_ds = session.query(DataSource).filter(DataSource.short_name == kurucz_short_name).one() except NoResultFound: raise NoResultFound("Kurucz data source is not found!") try: self.nist_ds = session.query(DataSource).filter(DataSource.short_name == nist_short_name).one() except NoResultFound: raise NoResultFound("NIST ASD data source is not found!") if self.chianti_ions: try: self.ch_ds = session.query(DataSource).filter(DataSource.short_name == chianti_short_name).one() except NoResultFound: raise NoResultFound("Chianti data source is not found!") self._atom_masses = None self._ionization_energies = None self._levels = None self._lines = None self._collisions = None self._macro_atom = None self._macro_atom_references = None self._zeta_data = None