def test_comparison_to_equivalent_particle_list(
physical_property, use_rms, include_neutrals
):
"""
Test that `IonizationState.average_ion` gives consistent results with
`ParticleList.average_particle` when the ratios of different particles
is the same between the `IonizationState` and the `ParticleList`.
"""
neutrals = 3 * ["H-1 0+"] + 2 * ["He-4 0+"] if include_neutrals else []
ions = 2 * ["p+"] + 3 * ["He-4 1+"] + 5 * ["α"]
particles = ParticleList(neutrals + ions)
ionic_fractions = {
"H-1": [0.6, 0.4],
"He-4": [0.2, 0.3, 0.5],
}
abundances = {"H-1": 1, "He-4": 2}
ionization_state_collection = IonizationStateCollection(
ionic_fractions, abundances=abundances
)
kwarg = {f"use_rms_{physical_property}": True}
expected_average_particle = particles.average_particle(**kwarg)
expected_average_quantity = getattr(expected_average_particle, physical_property)
actual_average_particle = ionization_state_collection.average_ion(
include_neutrals=include_neutrals, **kwarg
)
actual_average_quantity = getattr(actual_average_particle, physical_property)
assert_quantity_allclose(actual_average_quantity, expected_average_quantity)
def test_abundances_consistency():
"""Test that ``abundances`` and ``log_abundances`` are consistent."""
inputs = {"H": [1, 0], "He": [1, 0, 0]}
abundances = {"H": 1.0, "He": 0.1}
elements = abundances.keys()
log_abundances = {
element: np.log10(abundances[element])
for element in elements
}
instance_nolog = IonizationStateCollection(inputs, abundances=abundances)
instance_log = IonizationStateCollection(inputs,
log_abundances=log_abundances)
for element in elements:
assert np.allclose(
instance_log.abundances[element],
instance_nolog.abundances[element]), "abundances not consistent."
for element in elements:
assert np.allclose(instance_log.log_abundances[element],
instance_nolog.log_abundances[element]
), "log_abundances not consistent."
def test_simple_equality(self, test_name):
"""Test that __eq__ is not extremely broken."""
a = IonizationStateCollection(**tests[test_name])
b = IonizationStateCollection(**tests[test_name])
assert a == a, f"IonizationStateCollection instance does not equal itself."
assert (
a == b
), f"IonizationStateCollection instance does not equal identical instance."
def test_average_particle_exception():
"""
Test that `IonizationStateCollection.average_ion` raises the
appropriate exception when abundances are undefined and there is more
than one base element or isotope.
"""
ionization_states = IonizationStateCollection({"H": [1, 0], "He": [1, 0, 0]})
with pytest.raises(ParticleError):
ionization_states.average_ion()
def setup_class(cls):
# Create arguments to IonizationStateCollection that are all consistent
# with each other.
cls.ionic_fractions = {"H": [0.9, 0.1], "He": [0.99, 0.01, 0.0]}
cls.abundances = {"H": 1, "He": 0.08}
cls.n = 5.3 * u.m**-3
cls.number_densities = {
element: cls.ionic_fractions[element] * cls.n * cls.abundances[element]
for element in cls.ionic_fractions
}
# The keys that begin with 'ndens' have enough information to
# yield the number_densities attribute, whereas the keys that
# begin with "no_ndens" do not.
cls.dict_of_kwargs = {
"ndens1": {
"inputs": cls.ionic_fractions,
"abundances": cls.abundances,
"n0": cls.n,
},
"ndens2": {"inputs": cls.number_densities},
"no_ndens3": {"inputs": cls.ionic_fractions},
"no_ndens4": {"inputs": cls.ionic_fractions, "abundances": cls.abundances},
"no_ndens5": {"inputs": cls.ionic_fractions, "n0": cls.n},
}
cls.instances = {
key: IonizationStateCollection(**cls.dict_of_kwargs[key])
for key in cls.dict_of_kwargs
}
def test_instantiation(self, test_name):
try:
self.instances[test_name] = IonizationStateCollection(**tests[test_name])
except Exception:
pytest.fail(
f"Cannot create IonizationStateCollection instance for test='{test_name}'"
)
def test_iteration_with_nested_iterator():
ionization_states = IonizationStateCollection(["H", "He"])
i = 0
for ionization_state1 in ionization_states:
assert isinstance(ionization_state1, IonizationState)
for ionization_state2 in ionization_states:
assert isinstance(ionization_state2, IonizationState)
i += 1
assert i == 4
def test_average_ion_consistency(
base_particle,
ionic_fractions,
include_neutrals,
use_rms_mass,
use_rms_charge,
physical_type,
):
"""
Make sure that the average ions returned from equivalent `IonizationState`
and `IonizationStateCollection` instances are consistent with each other.
"""
ionization_state = IonizationState(base_particle, ionic_fractions)
ionization_state_collection = IonizationStateCollection(
{base_particle: ionic_fractions}
)
options = {
"include_neutrals": include_neutrals,
"use_rms_charge": use_rms_charge,
"use_rms_mass": use_rms_mass,
}
average_ion_from_ionization_state = ionization_state.average_ion(**options)
average_ion_from_ionization_state_collection = (
ionization_state_collection.average_ion(**options)
)
quantity_from_ion_state = getattr(average_ion_from_ionization_state, physical_type)
quantity_from_ion_collection = getattr(
average_ion_from_ionization_state_collection, physical_type
)
assert_quantity_allclose(
quantity_from_ion_state, quantity_from_ion_collection, rtol=1e-10
)
def setup_class(cls):
cls.initial_ionfracs = {
"H": np.array([0.87, 0.13]),
"He": np.array([0.24, 0.37, 0.39]),
}
cls.abundances = {"H": 1.0, "He": 0.0835}
cls.n = 10 * u.m**-3
cls.expected_densities = {
"H": np.array([8.7, 1.3]) * u.m**-3,
"He": np.array([0.2004, 0.30895, 0.32565]) * u.m**-3,
}
cls.expected_electron_density = 2.26025 * u.m**-3
cls.states = IonizationStateCollection(cls.initial_ionfracs,
abundances=cls.abundances,
n0=cls.n)
def setup_class(cls):
cls.elements = ["H", "He", "Li", "Fe"]
cls.instance = IonizationStateCollection(cls.elements)
cls.new_n = 5.153 * u.cm**-3
def setup_class(cls):
cls.states = IonizationStateCollection({
"H": [0.9, 0.1],
"He": [0.5, 0.4999, 1e-4]
})
def test_number_density_assignment():
instance = IonizationStateCollection(["H", "He"])
number_densities = [2, 3, 5] * u.m**-3
instance["He"] = number_densities
def test_hydrogen_deuterium():
instance = IonizationStateCollection(["H", "D"])
def test_len():
ionization_states = IonizationStateCollection(["H", "He"])
assert len(ionization_states) == 2
