pythonradex 2.0.2__py3-none-any.whl → 3.0.1__py3-none-any.whl

pythonradex/LAMDA_file.py

@@ -4,19 +4,20 @@ Created on Sun Nov 12 17:05:01 2017
 
 @author: gianni
 """
+
 from pythonradex import atomic_transition
 from scipy import constants
 import numpy as np
 
 
 def is_comment(line):
-    if line.replace(" ", "")[0] == "!":
+    if line.lstrip().startswith("!"):
         return True
     else:
         return False
 
 
-def read(datafilepath, read_frequencies, read_quantum_numbers=False):
+def read(datafilepath):
     """
     Read a data file that follows the LAMDA format (https://home.strw.leidenuniv.nl/~moldata/molformat.html).
     Such files can for example be downloaded from the EMAA (https://emaa.osug.fr/)
@@ -24,15 +25,6 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
 
     Args:
         datafilepath (:obj:`str`): The filepath to the LAMDA file.
-        read_frequencies (:obj:`bool`): Whether to read the frequencies of the
-            radiative transitions from the file or not. If False, calculates the
-            frequencies from the level energies given in the file. Setting this to
-            True can be useful since frequencies are sometimes given with more
-            significant digits than level energies. However, the LAMDA format does not
-            force a file to contain the frequencies, so they might not be present.
-        read_quantum_numbers (:obj:`bool`): Whether to read the quantum numbers
-            from the file. Defaults to False. The LAMDA format does not force a
-            file to list quantum numbers, so they might not be present.
 
     Returns:
         dict: A dictionary containing the data read from the file.
@@ -43,8 +35,9 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
             pythonradex.atomic_transitions.RadiativeTransition objects);
             'collisional transitions' (a list of
             pythonradex.atomic_transition.CollisionalTransition objects);
-            'quantum numbers' (list of str, empty if read_quantum_numbers
-            was set to False)
+            'frequencies' (list of float containing the frequencies of the
+            radiative transitions form the file; empty
+            if file does not contain frequencies)
     """
     # identifiers used in the LAMDA database files:
     LAMDA_coll_ID = {
@@ -59,11 +52,12 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
     datafile = open(datafilepath, "r")
     levels = []
     rad_transitions = []
+    frequencies = []
     coll_transitions = {}
-    quantum_numbers = []
     comment_offset = 0
     for i, line in enumerate(datafile):
-        if is_comment(line) or line == "" or line == "\n":
+        line = line.lstrip()
+        if is_comment(line) or line == "":
             comment_offset += 1
             continue
         if i == 0 + comment_offset:
@@ -76,9 +70,8 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
         if 3 + comment_offset <= i < 3 + comment_offset + n_levels:
             line_entries = line.split()
             leveldata = [float(string) for string in line_entries[:3]]
-            assert (
-                int(leveldata[0]) == i - 2 - comment_offset
-            ), "level numeration not consistent"
+            if int(leveldata[0]) != i - 2 - comment_offset:
+                raise RuntimeError("level numeration not consistent")
             # transforming energy from cm-1 to J; level indices starting from 0:
             lev = atomic_transition.Level(
                 g=leveldata[2],
@@ -86,8 +79,6 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
                 index=int(leveldata[0]) - 1,
             )
             levels.append(lev)
-            if read_quantum_numbers:
-                quantum_numbers.append(line_entries[3])
             continue
         if i == 3 + comment_offset + n_levels:
             n_rad_transitions = int(line)
@@ -101,15 +92,23 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
             up = next(level for level in levels if level.index == radtransdata[1] - 1)
             low = next(level for level in levels if level.index == radtransdata[2] - 1)
             rad_trans_kwargs = {"up": up, "low": low, "A21": radtransdata[3]}
-            if read_frequencies:
-                nu0 = radtransdata[4] * constants.giga
-                Delta_E = up.E - low.E
-                assert np.isclose(
-                    nu0, Delta_E / constants.h, atol=0, rtol=1e-3
-                ), "read frequency is inconsistent with level energies"
-                rad_trans_kwargs["nu0"] = nu0
             rad_trans = atomic_transition.RadiativeTransition(**rad_trans_kwargs)
             rad_transitions.append(rad_trans)
+            if len(radtransdata) >= 5:
+                # frequencies are there, so let's read them
+                frequencies.append(radtransdata[4] * constants.giga)
+                # Delta_E = up.E - low.E
+                # if not helpers.DeltaE_nu0_consistent(Delta_E=Delta_E,nu0=nu0):
+                #     filename = Path(datafilepath).name
+                #     nu0_from_Delta_E = Delta_E/constants.h
+                #     mean_nu0 = (nu0+nu0_from_Delta_E)/2
+                #     relative_diff = abs(nu0-nu0_from_Delta_E)/mean_nu0
+                #     warnings.warn(f"{filename}: transition from level {up.index+1} to {low.index+1}: "
+                #                   f"frequency ({nu0/constants.giga} GHz) inconsistent "
+                #                   +"with level energies (DeltaE corresponds "
+                #                   +f"to {nu0_from_Delta_E/constants.giga} GHz). "
+                #                   +f"relative difference: {relative_diff*100:.2g}%")
+                # rad_trans_kwargs["nu0"] = nu0
             continue
         if i == 4 + comment_offset + n_levels + n_rad_transitions:
             coll_partner_offset = 0
@@ -160,5 +159,5 @@ def read(datafilepath, read_frequencies, read_quantum_numbers=False):
         "levels": levels,
         "radiative transitions": rad_transitions,
         "collisional transitions": coll_transitions,
-        "quantum numbers": quantum_numbers,
+        "frequencies": frequencies,
     }

pythonradex/atomic_transition.py

@@ -5,10 +5,22 @@ Created on Sun Nov 12 17:03:55 2017
 @author: gianni
 """
 
+# note about frequencies:
+# in LAMDA files, the listed frequencies are only for "informational pruposes"
+# indeed, RADEX does not use them for any calculation, but just for the final
+# output to help the user to identify the transition
+# on the other hand, the frequencies have sometimes better accuracy than DeltaE/h
+# (e.g. for CO)
+# here, I adopt a similar approach as RADEX: I use DeltaE/h for cases where the position
+# of the line is not important, but I use the specific nu0 for cases where
+# the spectral position of the line matters (e.g. spectra etc.)
+
+
 from pythonradex import helpers
 import numpy as np
 from scipy import constants
 import numba as nb
+import warnings
 
 
 @nb.jit(nopython=True, cache=True)
@@ -71,7 +83,7 @@ class LineProfile:
             v (float or numpy.ndarray): velocity in [m/s]
 
         Returns:
-            float or numpy.ndarra: The line profile in [(m/s)\ :sup:`-1`]
+            float or numpy.ndarray: The line profile in [(m/s)\ :sup:`-1`]
         """
         nu = self.nu0 * (1 - v / constants.c)
         return self.phi_nu(nu) * self.nu0 / constants.c
@@ -245,26 +257,35 @@ class RadiativeTransition(Transition):
         low (pythonradex.atomic_transition.Level): the lower level of the transition
         Delta_E (:obj:`float`): the energy difference between the upper and lower level
         name (:obj:`str`): name of the transition
-        nu0 (:obj:`float`): rest frequency in [Hz]
+        Delta_E_over_h (:obj:`float`): Delta_E/h, corresponding to rest frequency in [Hz]
         A21 (:obj:`float`): Einstein A21 coefficient in [s\ :sup:`-1`]
         B21 (:obj:`float`): Einstein B21 coefficient in [sr m\ :sup:`2` Hz / Jy]
         B12 (:obj:`float`): Einstein B12 coefficient in [sr m\ :sup:`2` Hz / Jy]
     """
 
-    def __init__(self, up, low, A21, nu0=None):
-        Transition.__init__(self, up=up, low=low)
-        assert self.Delta_E > 0, "non-positive Delta_E for radiative transition"
+    def __init__(self, up, low, A21):
+        super().__init__(up=up, low=low)
+        if self.Delta_E <= 0:
+            raise RuntimeError("non-positive Delta_E for radiative transition")
         self.A21 = A21
-        nu0_from_Delta_E = self.Delta_E / constants.h
-        if nu0 is None:
-            self.nu0 = nu0_from_Delta_E
-        else:
-            # when reading LAMDA files, it is useful to specify nu0 directly, since
-            # it is sometimes given with more significant digits
-            assert np.isclose(nu0_from_Delta_E, nu0, atol=0, rtol=1e-3)
-            self.nu0 = nu0
-        self.B21 = helpers.B21(A21=self.A21, nu=self.nu0)
-        self.B12 = helpers.B12(A21=self.A21, nu=self.nu0, g1=self.low.g, g2=self.up.g)
+        # rest frequency, but I do want to distinguish it from the frequency listed
+        # in the LAMDA file, because sometimes those are not consistent with DeltaE/h
+        self.Delta_E_over_h = self.Delta_E / constants.h
+        # nu0_from_Delta_E = self.Delta_E / constants.h
+        # if nu0 is None:
+        #     self.nu0 = nu0_from_Delta_E
+        # else:
+        #     # when reading LAMDA files, it is useful to read nu0 rather than calculate
+        #     #from level energies, since nu0 is sometimes given with more significant
+        #     #digits than the level energies
+        #     if not helpers.DeltaE_nu0_consistent(Delta_E=self.Delta_E,nu0=nu0):
+        #         warnings.warn(f"Delta_E and nu0 are inconsistent (up.index = {up.index}, "
+        #                       +f"low.index={low.index}, A21={A21} s-1, nu0={nu0/constants.giga} GHz)")
+        #     self.nu0 = nu0
+        self.B21 = helpers.B21(A21=self.A21, nu=self.Delta_E_over_h)
+        self.B12 = helpers.B12(
+            A21=self.A21, nu=self.Delta_E_over_h, g1=self.low.g, g2=self.up.g
+        )
 
     def source_function(self, x1, x2):
         S = np.where(
@@ -286,7 +307,6 @@ class EmissionLine(RadiativeTransition):
         Delta_E (:obj:`float`): the energy difference between the upper and lower level
             in [J]
         name (:obj:`str`): name of the transition
-        nu0 (:obj:`float`): rest frequency in [Hz]
         A21 (:obj:`float`): Einstein A21 coefficient in [s\ :sup:`-1`]
         B21 (:obj:`float`): Einstein B21 coefficient in [sr m\ :sup:`2` Hz / Jy]
         B12 (:obj:`float`): Einstein B12 coefficient in [sr m\ :sup:`2` Hz / Jy]
@@ -295,27 +315,42 @@ class EmissionLine(RadiativeTransition):
     """
 
     def __init__(self, up, low, A21, line_profile_type, width_v, nu0=None):
-        RadiativeTransition.__init__(self, up=up, low=low, A21=A21, nu0=nu0)
-        self.line_profile = line_profiles[line_profile_type](
-            nu0=self.nu0, width_v=width_v
-        )
+        super().__init__(up=up, low=low, A21=A21)
+        if nu0 is None:
+            nu0 = self.Delta_E_over_h
+        else:
+            self.check_DeltaE_nu0_consistency(nu0)
+        self.line_profile = line_profiles[line_profile_type](nu0=nu0, width_v=width_v)
         self.tau_kwargs = {"A21": self.A21, "g_up": self.up.g, "g_low": self.low.g}
 
     @classmethod
     def from_radiative_transition(
-        cls, radiative_transition, line_profile_type, width_v
+        cls, radiative_transition, line_profile_type, width_v, nu0=None
     ):
         """Alternative constructor, taking an instance of RadiativeTransition,
-        a line profile class and the width of the line"""
+        a line profile class, the width of the line and optionally the rest
+        frequency"""
         return cls(
             up=radiative_transition.up,
             low=radiative_transition.low,
             A21=radiative_transition.A21,
             line_profile_type=line_profile_type,
             width_v=width_v,
-            nu0=radiative_transition.nu0,
+            nu0=nu0,
         )
 
+    def check_DeltaE_nu0_consistency(self, nu0):
+        if not np.isclose(self.Delta_E_over_h, nu0, atol=0, rtol=1e-2):
+            mean = (self.Delta_E_over_h + nu0) / 2
+            relative_diff = abs(self.Delta_E_over_h - nu0) / mean
+            warnings.warn(
+                "inconsistency between DeltaE/h and the frequency listed in LAMDA file"
+                + f" for transition {self.name}. "
+                + f" DeltaE/h={self.Delta_E_over_h/constants.giga} GHz, "
+                + f"listed frequency = {nu0/constants.giga}, relative difference ="
+                + f"{relative_diff*100:.2g}%"
+            )
+
     def tau(self, N1, N2, nu):
         r"""Computes the optical depth
 
@@ -351,7 +386,7 @@ class EmissionLine(RadiativeTransition):
             phi_nu=self.line_profile.phi_nu0,
             N1=N1,
             N2=N2,
-            nu=self.nu0,
+            nu=self.line_profile.nu0,
             **self.tau_kwargs,
         )
 
@@ -368,8 +403,9 @@ class CollisionalTransition(Transition):
     """
 
     def __init__(self, up, low, K21_data, Tkin_data):
-        Transition.__init__(self, up=up, low=low)
-        assert np.all(K21_data >= 0)
+        super().__init__(up=up, low=low)
+        if np.any(K21_data < 0):
+            raise ValueError("negative K21 values")
         self.K21_data = K21_data
         self.Tkin_data = Tkin_data
         self.Tkin_data_limits = np.min(self.Tkin_data), np.max(self.Tkin_data)
@@ -386,15 +422,13 @@ class CollisionalTransition(Transition):
             at the requested temperature(s)
 
         Raises:
-            AssertionError: If Tkin is outside the available temperature range.
+            ValueError: If Tkin is outside the available temperature range.
         """
         Tmin, Tmax = self.Tkin_data_limits
-        assert np.all(
-            Tmin <= Tkin
-        ), "requested temperature below minimum collider temperature"
-        assert np.all(
-            Tkin <= Tmax
-        ), "requested temperature above maximum collider temperature"
+        if np.any(Tkin < Tmin):
+            raise ValueError("requested temperature below minimum collider temperature")
+        if np.any(Tkin > Tmax):
+            raise ValueError("requested temperature above maximum collider temperature")
         K21 = np.interp(Tkin, self.Tkin_data, self.K21_data)
         K12 = compute_K12(
             K21=K21, g_up=self.up.g, g_low=self.low.g, Delta_E=self.Delta_E, Tkin=Tkin

pythonradex/escape_probability.py

@@ -4,6 +4,7 @@ Created on Sun Nov 12 17:31:02 2017
 
 @author: gianni
 """
+
 import numpy as np
 import numba as nb
 from pythonradex import escape_probability_functions
@@ -44,7 +45,7 @@ class StaticSphere(EscapeProbabilityStaticSphere):
         # for small tau, the Osterbrock formula becomes numerically unstable,
         # so we use a Taylor expansion
         min_tau = 1e-2
-        stable_region = tau > min_tau
+        stable_region = np.abs(tau) > min_tau
         flux_nu = (
             2
             * np.pi
@@ -59,7 +60,8 @@ class StaticSphere(EscapeProbabilityStaticSphere):
             * (tau / 3 - tau**2 / 8 + tau**3 / 30 - tau**4 / 144)
         )  # from Wolfram Alpha
         flux_nu = np.where(stable_region, flux_nu, flux_nu_Taylor)
-        assert np.all(np.isfinite(flux_nu))
+        if not np.all(np.isfinite(flux_nu)):
+            raise RuntimeError
         return flux_nu / np.pi
 
 
@@ -67,7 +69,7 @@ class StaticSphere(EscapeProbabilityStaticSphere):
 def exp_tau_factor(tau):
     # for very small tau, the exp can introduce numerical errors, so we
     # take care of that when computing (1-exp(-tau))
-    return np.where(tau < 1e-5, tau, 1 - np.exp(-tau))
+    return np.where(np.abs(tau) < 1e-5, tau, 1 - np.exp(-tau))
 
 
 class Flux1D:

pythonradex/escape_probability_functions.py

@@ -9,7 +9,6 @@ Created on Thu May 23 11:10:38 2024
 import numba as nb
 import numpy as np
 
-
 # It would be much more elegant to put these functions directly into the
 # classes defined in escape_probability.py. But I want to compile the beta functions
 # with numba, so I have to put these functions outside the class definitions
@@ -41,7 +40,8 @@ def identify_tau_regions(tau):
         + negative_tau_region.sum()
         + unreliable_negative_region.sum()
     )
-    assert total_region_points == len(tau), "selection needs to cover all points of tau"
+    if total_region_points != len(tau):
+        raise RuntimeError("selection needs to cover all points of tau")
     return (
         normal_tau_region,
         small_tau_region,
@@ -130,7 +130,8 @@ def generate_Taylor_beta(beta_ana, beta_Taylor):
         prob[negative] = beta_ana(tau[negative])
         # here I just use abs(tau) to stabilize the code
         prob[unreliable] = beta_ana(np.abs(tau[unreliable]))
-        assert np.all(np.isfinite(prob))
+        if not np.all(np.isfinite(prob)):
+            raise RuntimeError("negative escape probability")
         return clip_prob(prob)
 
     return beta
@@ -185,7 +186,8 @@ def beta_static_slab(tau):
     # should be ignored for tau < -1
     int_term = interpolated_integral_term(tau=tau)
     prob = np.where(tau < min_grid_tau, 1, int_term / tau)
-    assert np.all(np.isfinite(prob))
+    if not np.all(np.isfinite(prob)):
+        raise RuntimeError("negative escape probability")
     return clip_prob(prob)
 
 
@@ -213,14 +215,15 @@ def beta_LVG_sphere_RADEX(tau):
     # I use the same formulae as RADEX, except that I take care of negative tau
     # handling negative tau turns out to be important, e.g. for CO, Tkin=200,
     # width_v=3 km/s, Ntot=1e20 cm-2, RADEX gives an invalid solution
-    assert -7 < min_reliable_tau < -0.01
+    if not (-7 < min_reliable_tau < -0.01):
+        raise RuntimeError("unexpected value for min_reliable_tau")
     gtr7 = 7 <= tau
     less7 = (0.001 <= tau) & (tau < 7)
     small = (-0.001 <= tau) & (tau < 0.001)
     negative = (min_reliable_tau <= tau) & (tau < -0.001)
     unreliable_less7 = (-7 <= tau) & (tau < min_reliable_tau)
     unreliable_gtr7 = tau < -7
-    assert (
+    if not (
         gtr7.sum()
         + less7.sum()
         + small.sum()
@@ -228,7 +231,8 @@ def beta_LVG_sphere_RADEX(tau):
         + unreliable_less7.sum()
         + unreliable_gtr7.sum()
         == tau.size
-    )
+    ):
+        raise RuntimeError
     beta = np.empty_like(tau)
     beta[gtr7] = beta_LVG_sphere_RADEX_gtr7(tau[gtr7])
     beta[less7] = beta_LVG_sphere_RADEX_less7(tau[less7])

pythonradex/helpers.py

@@ -74,7 +74,8 @@ def relative_difference(a, b):
     a=0 and b!=0: return 1"""
     abs_diff = np.abs(a - b)
     rel_diff = np.where((a == 0) & (b == 0), 0, np.where(a == 0, 1, abs_diff / a))
-    assert not np.any(np.isnan(rel_diff))
+    if np.any(np.isnan(rel_diff)):
+        raise RuntimeError("relative difference calculation returned nan values")
     return np.abs(rel_diff)
 
 

pythonradex/intensity.py

@@ -46,9 +46,10 @@ class IntensityCalculator:
             if self.is_LVG_sphere
             else self.n_nu_elements["regular"]
         )
-        assert (
-            n_nu_elements % 2 == 1
-        ), "need odd number of elements to include nu0 in the array"
+        if n_nu_elements % 2 != 1:
+            raise RuntimeError(
+                "need odd number of elements to include nu0 in the array"
+            )
         middle_index = n_nu_elements // 2
         nu0 = self.emitting_molecule.nu0[transitions]
         width_nu = self.emitting_molecule.width_v / constants.c * nu0
@@ -168,7 +169,7 @@ class IntensityCalculator:
 
     def construct_tau_individual_line(self, line, nu, tau_nu0):
         # tau is prop to phi_nu/nu**2
-        normalisation = line.line_profile.phi_nu0 / line.nu0**2 / tau_nu0
+        normalisation = line.line_profile.phi_nu0 / line.line_profile.nu0**2 / tau_nu0
         return line.line_profile.phi_nu(nu) / nu**2 / normalisation
 
     def set_tau_lines(self):
@@ -224,14 +225,15 @@ class IntensityCalculator:
                     + " are optically thin!"
                 )
             for dust_func in (self.S_dust, self.tau_dust):
-                assert np.all(dust_func(self.nu) == 0), "LVG does not support dust"
+                if not np.all(dust_func(self.nu) == 0):
+                    raise RuntimeError("LVG does not support dust")
             I = np.zeros_like(self.nu)
             for line_index, line, tau_line in zip(
                 self.nu_selected_line_indices, self.nu_selected_lines, self.tau_lines
             ):
                 LVG_sphere_kwargs = {
                     "nu": self.nu,
-                    "nu0": line.nu0,
+                    "nu0": line.line_profile.nu0,
                     "V": self.V_LVG_sphere,
                 }
                 source_function = helpers.B_nu(T=self.Tex[line_index], nu=self.nu)
@@ -251,7 +253,8 @@ class IntensityCalculator:
         # this function works only if there are no overlapping lines
         # faster than calling the spectrum function, since I don't need to loop
         # over the lines
-        assert not self.emitting_molecule.any_line_has_overlap(transitions)
+        if self.emitting_molecule.any_line_has_overlap(transitions):
+            raise ValueError("overlapping lines not allowed in this function")
         nu = self.emitting_molecule.nu0[transitions]
         tau_lines = self.tau_nu0_individual_transitions[transitions]
         Tex = self.Tex[transitions]
@@ -265,7 +268,8 @@ class IntensityCalculator:
         kwargs = {"tau": tau_tot, "source_function": source_function}
         if self.is_LVG_sphere:
             for dust in (S_dust, tau_dust):
-                assert np.all(dust == 0), "LVG does not support dust"
+                if not np.all(dust == 0):
+                    raise RuntimeError("LVG does not support dust")
             return escape_probability.specific_intensity_nu0_lvg_sphere(**kwargs)
         else:
             return self.specific_intensity(**kwargs)

pythonradex/molecule.py

@@ -4,6 +4,7 @@ Created on Sun Nov 12 16:48:00 2017
 
 @author: gianni
 """
+
 from scipy import constants
 import numpy as np
 from pythonradex import LAMDA_file, atomic_transition
@@ -38,19 +39,12 @@ class Molecule:
             datafilepath (:obj:`str`): The filepath to the LAMDA file.
             partition_function (func): A user-supplied partition function of one argument
                 (temperature). Defaults to None. If equal to None, the partition function
-                will be calculated by using the data from the provided LAMDA file.
+                will be calculated by using the data from the LAMDA file.
         """
-        try:
-            # reading frequencies can be useful since frequencies are sometimes
-            # given with more significant digits than level energies. However,
-            # the LAMDA format does not orce a file to contain the frequencies,
-            # so they might not be present.
-            data = LAMDA_file.read(datafilepath=datafilepath, read_frequencies=True)
-        except:
-            data = LAMDA_file.read(datafilepath=datafilepath, read_frequencies=False)
-        self.levels = data["levels"]
-        self.rad_transitions = data["radiative transitions"]
-        self.coll_transitions = data["collisional transitions"]
+        self.lamda_data = LAMDA_file.read(datafilepath=datafilepath)
+        self.levels = self.lamda_data["levels"]
+        self.rad_transitions = self.lamda_data["radiative transitions"]
+        self.coll_transitions = self.lamda_data["collisional transitions"]
         self.n_levels = len(self.levels)
         self.n_rad_transitions = len(self.rad_transitions)
         self.set_partition_function(partition_function=partition_function)
@@ -58,7 +52,9 @@ class Molecule:
         self.A21 = np.array([line.A21 for line in self.rad_transitions])
         self.B21 = np.array([line.B21 for line in self.rad_transitions])
         self.B12 = np.array([line.B12 for line in self.rad_transitions])
-        self.nu0 = np.array([line.nu0 for line in self.rad_transitions])
+        self.Delta_E_over_h = np.array(
+            [line.Delta_E_over_h for line in self.rad_transitions]
+        )
         self.gup_rad_transitions = np.array(
             [line.up.g for line in self.rad_transitions]
         )
@@ -148,7 +144,8 @@ class Molecule:
             for i, line in enumerate(self.rad_transitions)
             if line.name == transition_name
         ]
-        assert len(candidate_numbers) == 1
+        if len(candidate_numbers) != 1:
+            raise RuntimeError("unable to get unique transition number")
         return candidate_numbers[0]
 
 
@@ -174,8 +171,8 @@ class EmittingMolecule(Molecule):
         datafilepath,
         line_profile_type,
         width_v,
-        read_frequencies=False,
         partition_function=None,
+        use_datafile_frequencies=True,
     ):
         """Constructs a new instance of the EmittingMolecule class using a LAMDA datafile
 
@@ -185,30 +182,33 @@ class EmittingMolecule(Molecule):
                 'rectangular' or 'Gaussian'
             width_v (:obj:`float`): The width of the line profile in [m/s]. For a Gaussian
                 line profile, this corresponds to the FWHM.
-            read_frequencies (:obj:`bool`): Whether to read the frequencies of the
-                radiative transitions from the file or not. If False, calculates the
-                frequencies from the level energies given in the file. Setting this to
-                True can be useful since frequencies are sometimes given with more
-                significant digits than level energies. However, the LAMDA format does not
-                force a file to contain the frequencies, so they might not be present.
             partition_function (func): A user-supplied partition function of one argument
                 (temperature). Defaults to None. If equal to None, the partition function
                 will be calculated by using the data from the provided LAMDA file.
+            use_datafile_frequencies (bool): whether to use the frequencies read from the LAMDA
+                file (if False, will use DeltaE/h).
         """
-        Molecule.__init__(
-            self, datafilepath=datafilepath, partition_function=partition_function
+        super().__init__(
+            datafilepath=datafilepath, partition_function=partition_function
         )
         self.width_v = width_v
         self.line_profile_type = line_profile_type
-        # convert radiative transitions to emission lines (but keep the same attribute name)
-        self.rad_transitions = [
-            atomic_transition.EmissionLine.from_radiative_transition(
-                radiative_transition=rad_trans,
+        # convert RadiativeTransition to EmissionLine (but keep the same attribute name)
+        converted_transitions = []
+        for i, line in enumerate(self.rad_transitions):
+            if use_datafile_frequencies:
+                nu0 = self.lamda_data["frequencies"][i]
+            else:
+                nu0 = None
+            converted = atomic_transition.EmissionLine.from_radiative_transition(
+                radiative_transition=line,
                 line_profile_type=line_profile_type,
                 width_v=width_v,
+                nu0=nu0,
             )
-            for rad_trans in self.rad_transitions
-        ]
+            converted_transitions.append(converted)
+        self.rad_transitions = converted_transitions
+        self.nu0 = np.array([line.line_profile.nu0 for line in self.rad_transitions])
         self.identify_overlapping_lines()
         if self.any_line_has_overlap(line_indices=range(self.n_rad_transitions)):
             self.has_overlapping_lines = True
@@ -218,16 +218,18 @@ class EmittingMolecule(Molecule):
         self.Tkin_data_limits = {}
         for collider, coll_transitions in self.coll_transitions.items():
             self.Tkin_data[collider] = coll_transitions[0].Tkin_data
-            assert np.all(self.Tkin_data[collider][:-1] < self.Tkin_data[collider][1:])
+            if np.any(self.Tkin_data[collider][:-1] >= self.Tkin_data[collider][1:]):
+                raise RuntimeError
             for coll_trans in coll_transitions:
-                assert np.all(coll_trans.Tkin_data == self.Tkin_data[collider])
+                if np.any(coll_trans.Tkin_data != self.Tkin_data[collider]):
+                    raise RuntimeError
             self.Tkin_data_limits[collider] = np.min(self.Tkin_data[collider]), np.max(
                 self.Tkin_data[collider]
             )
         self.set_K21_matrix()
         # collecting phi_nu0 and coll parameters, needed for numba-compiled functions:
         self.phi_nu0 = np.array(
-            [line.line_profile.phi_nu(line.nu0) for line in self.rad_transitions]
+            [line.line_profile.phi_nu0 for line in self.rad_transitions]
         )
         self.coll_gups = {}
         self.coll_glows = {}
@@ -364,7 +366,8 @@ class EmittingMolecule(Molecule):
 
     def interpolate_K(self, Tkin, collider):
         Tlimits = self.Tkin_data_limits[collider]
-        assert Tlimits[0] <= Tkin <= Tlimits[1]
+        if not (Tlimits[0] <= Tkin <= Tlimits[1]):
+            raise ValueError("Tkin outside bounds")
         output = {}
         Tkin_data = self.Tkin_data[collider]
         j = np.searchsorted(Tkin_data, Tkin, side="left")

pythonradex/radiative_transfer.py

@@ -66,6 +66,7 @@ class Source:
         geometry,
         line_profile_type,
         width_v,
+        use_datafile_frequencies=True,
         use_Ng_acceleration=True,
         treat_line_overlap=False,
         warn_negative_tau=True,
@@ -99,6 +100,14 @@ class Source:
                 we can also say that width_v=dv/dr*2*R. For "LVG slab", width_v=dv/dz*Z
                 where Z is the depth of the slab and dv/dz the constant velocity
                 gradient of the slab.
+            use_datafile_frequencies (bool): whether to use the frequencies read from the LAMDA
+                file (if False, will use Delta_E/h). Defaults to True. In principle, the
+                frequencies in a LAMDA-formatted file are only for informational purposes.
+                However, they are sometimes more accurate than Delta_E/h, where Delta_E is
+                the energy difference between the two levels of the transition, as computed
+                from the level energies in the file. Using the frequencies can have
+                advantages especially if one models spectra. But the frequencies and level
+                energies in the files are not always fully consistent.
             use_Ng_acceleration (:obj:`bool`): Whether to use Ng acceleration. Defaults
                 to True.
             treat_line_overlap (:obj:`bool`): Whether to treat the overlap of emission
@@ -116,13 +125,15 @@ class Source:
                 by general user. Defaults to False.
 
         """
-        assert (
-            width_v < 10000 * constants.kilo
-        ), "assumption of small nu0/Delta_nu for flux calculation not satisfied"
+        if width_v >= 10000 * constants.kilo:
+            raise ValueError(
+                "assumption of small nu0/Delta_nu for flux calculation not satisfied"
+            )
         self.emitting_molecule = EmittingMolecule(
             datafilepath=datafilepath,
             line_profile_type=line_profile_type,
             width_v=width_v,
+            use_datafile_frequencies=use_datafile_frequencies,
         )
         self.treat_line_overlap = treat_line_overlap
         self.geometry_name = geometry
@@ -264,9 +275,10 @@ class Source:
                 "tau_dust": tau_dust,
             }
             for p_name, p in params.items():
-                assert (
-                    p is not None
-                ), f"for initial setup, all params need to be defined; {p_name} missing"
+                if p is None:
+                    raise ValueError(
+                        f"for initial setup, all params need to be defined; {p_name} missing"
+                    )
             self.rate_equations = rate_equations.RateEquations(
                 molecule=self.emitting_molecule,
                 treat_line_overlap=self.treat_line_overlap,
@@ -418,13 +430,13 @@ class Source:
                     self.emitting_molecule.rad_transitions[i]
                     for i in negative_tau_transition_indices
                 ]
-                warnings.warn("negative optical depth!")
+                warn_message = "negative optical depth!"
                 for i, trans in zip(
                     negative_tau_transition_indices, negative_tau_transitions
                 ):
-                    print(
-                        f"{trans.name}: tau_nu0 = {self.tau_nu0_individual_transitions[i]:.3g}"
-                    )
+                    warn_message += f" {trans.name}: tau_nu0 = {self.tau_nu0_individual_transitions[i]:.3g};"
+                warn_message = warn_message[:-1]
+                warnings.warn(warn_message)
         self.level_pop = level_pop
         self.Tex = self.emitting_molecule.get_Tex(level_pop)
         self.intensity_calculator = intensity.IntensityCalculator(
@@ -684,7 +696,7 @@ class Source:
         for i, line in enumerate(self.emitting_molecule.rad_transitions):
             output = (
                 f"{line.up.index:>4d} {line.low.index:>4d} "
-                + f"{line.nu0/constants.giga:>14.6f} {self.Tex[i]:>10.2f} "
+                + f"{line.line_profile.nu0/constants.giga:>14.6f} {self.Tex[i]:>10.2f} "
                 + f"{self.level_pop[line.low.index]:>14g} "
                 + f"{self.level_pop[line.up.index]:>14g} "
                 + f"{self.tau_nu0_individual_transitions[i]:>14g}"

pythonradex/rate_equations.py

@@ -65,9 +65,10 @@ class RateEquations:
 
     def assign_func_nu(self, func_name, argument):
         if isinstance(argument, numbers.Number):
-            assert (
-                argument >= 0
-            ), "ext_background, T_dust or tau_dust cannot be negative"
+            if argument < 0:
+                raise ValueError(
+                    "ext_background, T_dust or tau_dust cannot be negative"
+                )
             setattr(self, func_name, self.generate_constant_func(const_value=argument))
         else:
             setattr(self, func_name, argument)
@@ -390,8 +391,9 @@ class RateEquations:
         Gamma = self.GammaR(level_population=level_population) + self.GammaC
         Gamma[0, :] = np.ones(self.molecule.n_levels)
         fractional_population = np.linalg.solve(Gamma, b=self.b)
-        assert np.all(fractional_population >= 0), (
-            "negative level population, potentially due to high column"
-            + "density and/or low collider density"
-        )
+        if np.any(fractional_population < 0):
+            raise RuntimeError(
+                "negative level population, potentially due to high column"
+                + "density and/or low collider density"
+            )
         return fractional_population

{pythonradex-2.0.2.dist-info → pythonradex-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: pythonradex
-Version: 2.0.2
+Version: 3.0.1
 Summary: 1D non-LTE radiative transfer
 Project-URL: Documentation, https://pythonradex.readthedocs.io/en/latest/
 Project-URL: Issues, https://github.com/gica3618/pythonradex/issues
@@ -9,12 +9,14 @@ Author-email: Gianni Cataldi <cataldi.gia@gmail.com>
 License-Expression: MIT
 License-File: LICENSE.txt
 Keywords: non-LTE,radex,radiative transfer
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Requires-Python: >=3.10
 Requires-Dist: numba>=0.61.0
 Requires-Dist: numpy>=2.0

pythonradex-3.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+pythonradex/LAMDA_file.py,sha256=oVUVYNjuJl3ZMBd_T8dknWb0WExL12KuZbYsh1ZMalo,6716
+pythonradex/__init__.py,sha256=iLQfJx9dbUoHmti29jtlTNopYzTdS7O1mBbZfb0Kin0,223
+pythonradex/atomic_transition.py,sha256=1-l8PJYcbwutzrM5QxLOi0fc3pz-13u4pYvCYdJp1HM,16313
+pythonradex/escape_probability.py,sha256=UCs0Ec4AGEN92uN9A79cuFsapa7fUFGKD8tNtODqrV0,5608
+pythonradex/escape_probability_functions.py,sha256=oLoY8h8zXqpdz0cYq3Cc7TFKVV1Lqa6Si6pGd4xopE4,9419
+pythonradex/helpers.py,sha256=IY_EUtvMA12uuQxwFz-CZNEPuQqPBLl7xl7FVb5-w6k,3285
+pythonradex/intensity.py,sha256=6oOltX6-h_6QsIr5jvscN0yCN_JsTpwXm-3uTmsTX2M,12199
+pythonradex/molecule.py,sha256=hMZqidSXIIGYOx_zqE7Ccylsuo6718GOESkI3Mbk5B8,17489
+pythonradex/radiative_transfer.py,sha256=DvKyRss9ByDX4sXG5PSV112ACOK4GYmc9gpTWmST-Es,34012
+pythonradex/rate_equations.py,sha256=x8CYB6O7ErYD65JiBiBQe4XqTMySSowqAijcCCQU9bk,15410
+pythonradex-3.0.1.dist-info/METADATA,sha256=lbbXRE9JlomsGm9_vc3vhEsDDdFInoepo885rxtckqU,2706
+pythonradex-3.0.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pythonradex-3.0.1.dist-info/licenses/LICENSE.txt,sha256=biAf-Gv0h8Xr2r-CuwVZJsJKnj6WCL6KJfof8mz-M0U,1071
+pythonradex-3.0.1.dist-info/RECORD,,

{pythonradex-2.0.2.dist-info → pythonradex-3.0.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pythonradex-2.0.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-pythonradex/LAMDA_file.py,sha256=Mk_CM5MZTpd-TsirfhkGpv_XvXbPk25iAMB0yeyGcxU,6816
-pythonradex/__init__.py,sha256=iLQfJx9dbUoHmti29jtlTNopYzTdS7O1mBbZfb0Kin0,223
-pythonradex/atomic_transition.py,sha256=8fTmDZ4uSiHT5fHa_ANVqsdZDMNVn7q9eJUxGdr1qOE,14394
-pythonradex/escape_probability.py,sha256=FaK-m2rQUccsr7zwnupPPWBfHItCW_Sj3I61TE1ZgJU,5559
-pythonradex/escape_probability_functions.py,sha256=WNFgF66N8e8SajfJJkwRHxtMDhq7aGC_lOD5kcl0Q0A,9175
-pythonradex/helpers.py,sha256=kBSdLgsoh7wx80veLBtPx-nUyeRWMDdlaTm_LB7CW-I,3210
-pythonradex/intensity.py,sha256=poBcfRqtVURE-UGUI0x-9aIWbWhaH1xpQC0q5ET2Skk,11987
-pythonradex/molecule.py,sha256=4e2-1L8QHr4TavCUnNwolhwjMi6-AO98G6J_tFnSt5o,17658
-pythonradex/radiative_transfer.py,sha256=3tyC_e4CiLIYbaX3IKG1IdclAcKGYT7DyJZaMp_VNJ0,33065
-pythonradex/rate_equations.py,sha256=mFLO6GCT6lADg6niGcVwTamN9gPJXAwgs75o86zjnYE,15338
-pythonradex-2.0.2.dist-info/METADATA,sha256=g_ieHy-bFHDd0KmZGWByqOZkMynAOLWw09fEwFMf2dU,2591
-pythonradex-2.0.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-pythonradex-2.0.2.dist-info/licenses/LICENSE.txt,sha256=biAf-Gv0h8Xr2r-CuwVZJsJKnj6WCL6KJfof8mz-M0U,1071
-pythonradex-2.0.2.dist-info/RECORD,,