def test_atom_data_chianti_ions_subset(memory_session):
nist = DataSource.as_unique(memory_session, short_name="nist-asd")
ch = DataSource.as_unique(memory_session, short_name="chianti_v8.0.2")
ku = DataSource.as_unique(memory_session, short_name="ku_latest")
with pytest.raises(ValueError):
atom_data = AtomData(memory_session,
selected_atoms="He, Be, B, N VI",
chianti_ions="He 1; N 5; Si 1")
def test_atom_data_chianti_ions_subset(memory_session):
nist = DataSource.as_unique(memory_session, short_name="nist-asd")
ch = DataSource.as_unique(memory_session, short_name="chianti_v8.0.2")
ku = DataSource.as_unique(memory_session, short_name="ku_latest")
with pytest.raises(ValueError):
atom_data = AtomData(memory_session,
selected_atoms="He, Be, B, N VI",
chianti_ions="He 1; N 5; Si 1")
def test_atom_data_init(memory_session):
nist = DataSource.as_unique(memory_session, short_name="nist-asd")
ch = DataSource.as_unique(memory_session, short_name="chianti_v8.0.2")
ku = DataSource.as_unique(memory_session, short_name="ku_latest")
atom_data = AtomData(memory_session,
selected_atoms="He, Be, B, N",
chianti_ions="He 1; N 5")
assert set(atom_data.selected_atomic_numbers) == set([2, 4, 5, 7])
assert set(atom_data.chianti_ions) == set([(2, 1), (7, 5)])
def test_atom_data_init(memory_session):
nist = DataSource.as_unique(memory_session, short_name="nist-asd")
ch = DataSource.as_unique(memory_session, short_name="chianti_v8.0.2")
ku = DataSource.as_unique(memory_session, short_name="ku_latest")
atom_data = AtomData(memory_session,
selected_atoms="He, Be, B, N",
chianti_ions="He 1; N 5")
assert set(atom_data.selected_atomic_numbers) == set([2, 4, 5, 7])
assert set(atom_data.chianti_ions) == set([(2,1), (7,5)])
def test_atomic_weights_query(foo_session, atomic_number, ds_short_name, expected_weight):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
atom, atom_weight = foo_session.query(Atom, AtomWeight).\
filter(Atom.atomic_number == atomic_number).\
join(Atom.weights).\
filter(AtomWeight.data_source == data_source).one()
assert_quantity_allclose([atom_weight.quantity], expected_weight)
def test_atomic_quantity_convert_to(foo_session):
H = foo_session.query(Atom).filter(Atom.atomic_number==1).one()
nist = DataSource.as_unique(foo_session, short_name="nist")
aw = foo_session.query(AtomicWeight).filter(and_(AtomicWeight.atom==H,
AtomicWeight.data_source==nist)).one()
aw.to(u.ng)
assert_almost_equal(aw.value, 1.6735573234079996e-15)
def test_atomic_weights_atom_relationship(foo_session):
nist = DataSource.as_unique(foo_session, short_name="nist")
q = foo_session.query(Atom, AtomicWeight).\
join(Atom.quantities.of_type(AtomicWeight)).\
filter(AtomicWeight.data_source == nist).first()
assert_almost_equal(q.AtomicWeight.value, 1.00784)
def test_gfall_ingester_ingest_lines(memory_session, gfall_ingester,
atomic_number, ion_charge,
level_index_lower, level_index_upper,
exp_wavelength, exp_gf_value):
gfall_ingester.ingest(levels=True, lines=True)
ion = Ion.as_unique(memory_session,
atomic_number=atomic_number,
ion_charge=ion_charge)
data_source = DataSource.as_unique(memory_session, short_name="ku_latest")
lower_level = memory_session.query(Level).\
filter(and_(Level.data_source==data_source,
Level.ion==ion,
Level.level_index==level_index_lower)).one()
upper_level = memory_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == level_index_upper)).one()
line = memory_session.query(Line).\
filter(and_(Line.data_source==data_source,
Line.lower_level==lower_level,
Line.upper_level==upper_level)).one()
wavelength = line.wavelengths[0].quantity
gf_value = line.gf_values[0].quantity
assert_quantity_allclose(wavelength, exp_wavelength)
assert_quantity_allclose(gf_value, exp_gf_value)
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 test_atom_merge_new_quantity(foo_session, H):
cr = DataSource.as_unique(foo_session, short_name="cr")
H.merge_quantity(foo_session, AtomicWeight(data_source=cr, quantity=1.00754*u.u, std_dev=3e-5,))
foo_session.commit()
res = foo_session.query(AtomicWeight).filter(and_(AtomicWeight.atom==H,
AtomicWeight.data_source==cr)).one()
assert_almost_equal(res.quantity.value, 1.00754)
def __init__(self, session, data_fn, ds_name='knox_long'):
self.session = session
self.data_fn = data_fn
self.data_source = DataSource.as_unique(self.session,
short_name=ds_name)
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 test_line_quantities_query(foo_session, atomic_number, ion_charge, ds_short_name,
lower_level_index, upper_level_index,
expected_wavelength, expected_a_value, expected_gf_value):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion = Ion.as_unique(foo_session, atomic_number=atomic_number, ion_charge=ion_charge)
lower_level = foo_session.query(Level).\
filter(and_(Level.data_source==data_source,
Level.ion == ion,
Level.level_index == lower_level_index)).one()
upper_level = foo_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == upper_level_index)).one()
line = foo_session.query(Line).\
filter(and_(Line.data_source == data_source,
Line.lower_level == lower_level,
Line.upper_level == upper_level)).one()
wavelength = line.wavelengths[0].quantity
a_value = line.a_values[0].quantity
gf_value = line.gf_values[0].quantity
assert_quantity_allclose(wavelength, expected_wavelength)
assert_quantity_allclose(a_value, expected_a_value)
assert_quantity_allclose(gf_value, expected_gf_value)
def test_atomic_weights_convert_to(foo_session, atomic_number, ds_short_name, expected_weight_value):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
atom, atom_weight_value = foo_session.query(Atom, AtomWeight.quantity.to(u.solMass).value). \
filter(Atom.atomic_number == atomic_number). \
join(Atom.weights). \
filter(AtomWeight.data_source == data_source).one()
assert_almost_equal(atom_weight_value, expected_weight_value)
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 test_atomic_weights_unique_constraint(foo_session):
nist = DataSource.as_unique(foo_session, short_name="nist")
H = foo_session.query(Atom).filter(Atom.atomic_number==1).one()
H.quantities.append(
AtomicWeight(data_source=nist, value=666)
)
with pytest.raises(IntegrityError):
foo_session.commit()
def test_atom_merge_new_quantity(foo_session):
H = foo_session.query(Atom).filter(Atom.atomic_number==1).one()
cr = DataSource.as_unique(foo_session, short_name="cr")
H.merge_quantity(foo_session, AtomicWeight(data_source=cr, unit=u.u, value=1.00754, std_dev=3e-5,))
foo_session.commit()
q = foo_session.query(AtomicWeight).filter(and_(AtomicWeight.atom==H,
AtomicWeight.data_source==cr)).one()
assert_almost_equal(q.value, 1.00754)
def test_weightscomp_ingest_nonexisting_atomic_weights(atomic_number, nom_val, std_dev, weightscomp_ingester, test_session):
weightscomp_ingester.ingest(test_session)
nist = DataSource.as_unique(test_session, short_name="nist")
aw = test_session.query(AtomicWeight).\
filter(AtomicWeight.atomic_number==atomic_number).\
filter(AtomicWeight.data_source==nist).one()
assert_almost_equal(aw.value, nom_val)
assert_almost_equal(aw.std_dev, std_dev)
def test_atom_merge_existing_quantity(foo_session):
H = foo_session.query(Atom).filter(Atom.atomic_number==1).one()
nist = DataSource.as_unique(foo_session, short_name="nist")
H.merge_quantity(foo_session, AtomicWeight(data_source=nist, unit=u.u, value=1.00654, std_dev=4e-5,))
foo_session.commit()
q = foo_session.query(AtomicWeight).filter(and_(AtomicWeight.atom==H,
AtomicWeight.data_source==nist)).one()
assert_almost_equal(q.value, 1.00654)
def test_level_g_hybrid_attribute_expression(foo_session, atomic_number, ion_charge, ds_short_name, level_index, exp_g):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion = Ion.as_unique(foo_session, atomic_number=atomic_number, ion_charge=ion_charge)
g = foo_session.query(Level.g). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == level_index)).scalar()
assert g == exp_g
def test_ionization_energies_query(foo_session, atomic_number, ion_charge, ds_short_name,
method, expected_ionization_energy):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion, ionization_energy = foo_session.query(Ion, IonizationEnergy).\
filter(and_(Ion.atomic_number == atomic_number,
Ion.ion_charge == ion_charge)).\
join(Ion.ionization_energies).\
filter(and_(IonizationEnergy.data_source == data_source,
IonizationEnergy.method == method)).one()
assert_quantity_allclose([ionization_energy.quantity], expected_ionization_energy)
def __init__(self, session, ds_short_name, parser, downloader):
self.parser = parser
self.downloader = downloader
self.session = session
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()
if not self.requirements_satisfied():
raise IngesterError('Requirements for ingest are not satisfied!')
def ingest(self, session):
""" *Only* ingests atomic weights *for now* """
print "Ingesting atomic weights"
atomic_df = self.parser.prepare_atomic_dataframe()
atomic_df = atomic_df[pd.notnull(atomic_df[AW_VAL_COL])]
data_source = DataSource.as_unique(session, short_name=self.ds_short_name)
for atom_num, row in atomic_df.iterrows():
atom = session.query(Atom).filter(Atom.atomic_number==atom_num).one()
atom.merge_quantity(session,
AtomicWeight(data_source=data_source, value=row[AW_VAL_COL], std_dev=row[AW_SD_COL], unit=u.u))
def test_gfall_ingester_ingest_levels(memory_session, gfall_ingester, atomic_number, ion_charge, level_index,
exp_energy, exp_j, exp_method):
gfall_ingester.ingest(levels=True, lines=False)
ion = Ion.as_unique(memory_session, atomic_number=atomic_number, ion_charge=ion_charge)
data_source = DataSource.as_unique(memory_session, short_name="ku_latest")
level, energy = memory_session.query(Level, LevelEnergy).\
filter(and_(Level.ion==ion,
Level.level_index==level_index),
Level.data_source==data_source).\
join(Level.energies).one()
assert_almost_equal(level.J, exp_j)
assert_quantity_allclose(energy.quantity, exp_energy.to(u.eV, equivalencies=u.spectral()))
assert energy.method == exp_method
def __init__(self, session, fname=None, ds_name='knox_long'):
self.session = session
if fname is None:
self.fname = ZETA_DATA_URL
else:
self.fname = fname
self.data_source = DataSource.as_unique(self.session,
short_name=ds_name)
if self.data_source.data_source_id is None:
self.session.flush()
def test_ionization_energies_query(foo_session, atomic_number, ion_charge, ds_short_name,
level_index, method, expected_level_energy_value):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion = Ion.as_unique(foo_session, atomic_number=atomic_number, ion_charge=ion_charge)
level, level_energy_value = foo_session.query(Level,
LevelEnergy.quantity.to(u.Unit("cm-1"), equivalencies=u.spectral()).value). \
filter(and_(Level.ion == ion,
Level.data_source == data_source),
Level.level_index == level_index). \
join(Level.energies). \
filter(and_(LevelEnergy.data_source == data_source,
LevelEnergy.method == method)).one()
assert_almost_equal(level_energy_value, expected_level_energy_value)
def test_level_query(foo_session, atomic_number, ion_charge, ds_short_name, level_index,
configuration, term, L, J, spin_multiplicity, parity):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion = Ion.as_unique(foo_session, atomic_number=atomic_number, ion_charge=ion_charge)
level = foo_session.query(Level).\
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == level_index)).one()
assert level.configuration == configuration
assert level.term == term
assert level.L == L
assert_almost_equal(level.J, J)
assert level.spin_multiplicity == spin_multiplicity
assert level.parity == parity
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 test_line_wavelength_medium(foo_session, atomic_number, ion_charge, ds_short_name,
lower_level_index, upper_level_index, expected_medium):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion = Ion.as_unique(foo_session, atomic_number=atomic_number, ion_charge=ion_charge)
lower_level = foo_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == lower_level_index)).one()
upper_level = foo_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == upper_level_index)).one()
line = foo_session.query(Line). \
filter(and_(Line.data_source == data_source,
Line.lower_level == lower_level,
Line.upper_level == upper_level)).one()
wavelength = line.wavelengths[0]
assert wavelength.medium == expected_medium
def test_weithscomp_ingest_existing_atomic_weights(atomic_number, nom_val, std_dev, weightscomp_ingester, test_session):
nist = DataSource.as_unique(test_session, short_name="nist")
atom = test_session.query(Atom).filter(Atom.atomic_number==atomic_number).one()
#import pdb; pdb.set_trace()
atom.quantities = [
AtomicWeight(data_source=nist, value=9.9999, unit=u.u),
]
test_session.commit()
weightscomp_ingester.ingest(test_session)
q = test_session.query(Atom, AtomicWeight).\
join(Atom.quantities.of_type(AtomicWeight)).\
filter(AtomicWeight.data_source==nist).\
filter(Atom.atomic_number==atomic_number).one()
assert q.AtomicWeight.atomic_number == atomic_number
assert_almost_equal(q.AtomicWeight.value, nom_val)
assert_almost_equal(q.AtomicWeight.std_dev, std_dev)
def test_gfall_ingester_ingest_lines_wavelength_medium(memory_session, gfall_ingester, atomic_number, ion_charge,
level_index_lower, level_index_upper,
exp_wavelength, exp_medium):
gfall_ingester.ingest(levels=True, lines=True)
ion = Ion.as_unique(memory_session, atomic_number=atomic_number, ion_charge=ion_charge)
data_source = DataSource.as_unique(memory_session, short_name="ku_latest")
lower_level = memory_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == level_index_lower)).one()
upper_level = memory_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == level_index_upper)).one()
line = memory_session.query(Line). \
filter(and_(Line.data_source == data_source,
Line.lower_level == lower_level,
Line.upper_level == upper_level)).one()
wavelength = line.wavelengths[0]
assert_quantity_allclose(wavelength.quantity, exp_wavelength)
assert wavelength.medium == exp_medium
def test_e_collision_quantities_query(foo_session, atomic_number, ion_charge, ds_short_name,
lower_level_index, upper_level_index,
expected_energy, expected_temp_strengths):
data_source = DataSource.as_unique(foo_session, short_name=ds_short_name)
ion = Ion.as_unique(foo_session, atomic_number=atomic_number, ion_charge=ion_charge)
lower_level = foo_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == lower_level_index)).one()
upper_level = foo_session.query(Level). \
filter(and_(Level.data_source == data_source,
Level.ion == ion,
Level.level_index == upper_level_index)).one()
e_col = foo_session.query(ECollision). \
filter(and_(ECollision.data_source == data_source,
ECollision.lower_level == lower_level,
ECollision.upper_level == upper_level)).one()
energy = e_col.energies[0].quantity
assert_quantity_allclose(energy, expected_energy)
for temp_strength, expected_temp_strength in zip(e_col.temp_strengths_tuple, expected_temp_strengths):
assert_allclose(temp_strength, expected_temp_strength)
def ingest(self, session):
data_source = DataSource.as_unique(session, short_name=self.ds_short_name)
return "Ingested"
def test_weightscomp_ingest_default_count(weightscomp_ingester, test_session):
weightscomp_ingester.download()
weightscomp_ingester.ingest(test_session)
nist = DataSource.as_unique(test_session, short_name="nist")
assert test_session.query(AtomicWeight).\
filter(AtomicWeight.data_source==nist).count() == 94
def ingest(self, session):
data_source = DataSource.as_unique(session,
short_name=self.ds_short_name)
return "Ingested"
def nist(foo_session):
return DataSource.as_unique(foo_session, short_name="nist")
def test_data_source_as_unique(memory_session):
nist = DataSource.as_unique(memory_session, short_name="nist",
name="National Institute of Standards and Technology")
nist2 = DataSource.as_unique(memory_session, short_name="nist")
assert nist is nist2
def test_data_source_as_unique(foo_session):
nist = DataSource.as_unique(foo_session, short_name="nist",
name="National Institute of Standards and Technology")
nist2 = DataSource.as_unique(foo_session, short_name="nist",
name="National Institute of Standards and Technology")
assert nist is nist2