pythonradex 1.0.0__py3-none-any.whl

pythonradex/LAMDA_file.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""
+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] == '!':
+        return True
+    else:
+        return False
+
+def read(datafilepath,read_frequencies,read_quantum_numbers=False):
+    '''
+    Read a LAMDA data file. LAMDA files can be downloaded from the LAMDA database
+    at http://home.strw.leidenuniv.nl/~moldata
+
+    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.
+            The following keys give acces to lists containing the data.
+            The elements of these lists are in the order they appear in the file.
+            'levels' (a list of pythonradex.atomic_transition.Level objects);
+            'radiative transitions' (a list of 
+            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)
+    '''
+    #identifiers used in the LAMDA database files:
+    LAMDA_coll_ID = {'1':'H2','2':'para-H2','3':'ortho-H2','4':'e',
+                     '5':'H','6':'He','7':'H+'}
+    datafile = open(datafilepath,'r')
+    levels = []
+    rad_transitions = []
+    coll_transitions = {}
+    quantum_numbers = []
+    comment_offset = 0
+    for i,line in enumerate(datafile):
+        if is_comment(line) or line=='' or line=='\n':
+            comment_offset += 1
+            continue
+        if i == 0+comment_offset:
+            continue
+        if i == 1+comment_offset:
+            continue
+        if i == 2+comment_offset:
+            n_levels = int(line)
+            continue
+        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'
+            #transforming energy from cm-1 to J; level numbers starting from 0:
+            lev = atomic_transition.Level(
+                        g=leveldata[2],
+                        E=constants.c*constants.h*leveldata[1]/constants.centi,
+                        number=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)
+            continue
+        if 4+comment_offset+n_levels <= i < 4+comment_offset+n_levels+n_rad_transitions:
+            radtransdata = [float(string) for string in line.split()]
+            up = next(level for level in levels if level.number==radtransdata[1]-1)
+            low = next(level for level in levels if level.number==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)
+            continue
+        if i == 4+comment_offset+n_levels+n_rad_transitions:
+            coll_partner_offset = 0
+            continue
+        if i == 5+comment_offset+n_levels+n_rad_transitions + coll_partner_offset:
+            coll_ID = LAMDA_coll_ID[line[0]]
+            coll_transitions[coll_ID] = []
+            continue
+        if i == 6+comment_offset+n_levels+n_rad_transitions + coll_partner_offset:
+            n_coll_transitions = int(line)
+            continue
+        if i == 7+comment_offset+n_levels+n_rad_transitions + coll_partner_offset:
+            continue #this lines contains the number of temperature elements
+        if i == 8+comment_offset+n_levels+n_rad_transitions + coll_partner_offset:
+            coll_temperatures = np.array([float(string) for string in line.split()])
+            continue
+        last_coll_trans_i = 9+comment_offset+n_levels+n_rad_transitions\
+                               +coll_partner_offset+n_coll_transitions-1
+        if 9+comment_offset+n_levels+n_rad_transitions+coll_partner_offset <= i <=\
+                 last_coll_trans_i:
+            coll_trans_data = [float(string) for string in line.split()]
+            up = next(level for level in levels if level.number==coll_trans_data[1]-1)
+            low = next(level for level in levels if level.number==coll_trans_data[2]-1)
+            K21_data = np.array(coll_trans_data[3:])*constants.centi**3
+            coll_trans = atomic_transition.CollisionalTransition(
+                                  up=up,low=low,K21_data=K21_data,
+                                  Tkin_data=coll_temperatures)
+            coll_transitions[coll_ID].append(coll_trans)
+            if i == last_coll_trans_i:
+                coll_partner_offset += 4+n_coll_transitions
+                continue
+    datafile.close()
+    return {'levels':levels,'radiative transitions':rad_transitions,
+            'collisional transitions':coll_transitions,'quantum numbers':quantum_numbers}

pythonradex/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2025-present Gianni Cataldi <cataldi.gia@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.0.1"

pythonradex/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+Python implementation of the RADEX radiative transfer code
+"""

pythonradex/atomic_transition.py

@@ -0,0 +1,351 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Nov 12 17:03:55 2017
+
+@author: gianni
+"""
+
+from pythonradex import helpers
+import numpy as np
+from scipy import constants
+import numba as nb
+
+
+@nb.jit(nopython=True,cache=True) 
+def tau_nu(A21,phi_nu,g_low,g_up,N1,N2,nu):
+    return constants.c**2/(8*np.pi*nu**2)*A21*phi_nu*(g_up/g_low*N1-N2)
+
+@nb.jit(nopython=True,cache=True,error_model='numpy')
+def Tex(Delta_E,g_low,g_up,x1,x2):
+    return np.where((x1==0) & (x2==0),0,
+                    -Delta_E/(constants.k*np.log(g_low*x2/(g_up*x1))))
+
+@nb.jit(nopython=True,cache=True)
+def compute_K12(K21,g_up,g_low,Delta_E,Tkin):
+    #see RADEX manual
+    return (g_up/g_low*K21*np.exp(-Delta_E/(constants.k*Tkin)))
+
+
+class LineProfile():
+    
+    '''Abstract class representing a general, normalised line profile.'''
+
+    n_nu_elements_for_coarse_array = 10
+
+    def __init__(self,nu0,width_v):
+        self.nu0 = nu0
+        self.width_v = width_v
+        self.width_nu = helpers.Delta_nu(Delta_v=self.width_v,nu0=self.nu0)
+        self.initialise_phi_nu_params()
+        # self.initialise_coarse_nu_array()
+        # self.coarse_phi_nu_array = self.phi_nu(nu=self.coarse_nu_array)
+        self.phi_nu0 = self.phi_nu(nu=self.nu0)
+
+    def initialise_phi_nu_params(self):
+        raise NotImplementedError
+    
+    def phi_nu(self,nu):
+        r'''The value of the line profile in frequency space.
+        
+        The line profile is normalised such that its integral over frequency equals 1.
+
+        Args:
+            nu (float or numpy.ndarray): frequency in [Hz]
+        
+        Returns:
+            float or numpy.ndarray: The line profile in [Hz\ :sup:`-1`]
+        '''
+        raise NotImplementedError
+
+    def phi_v(self,v):
+        r'''The value of the line profile in velocity space.
+        
+        The line profile is normalised such that its integral over velocity equals 1.
+
+        Args:
+            v (float or numpy.ndarray): velocity in [m/s]
+        
+        Returns:
+            float or numpy.ndarra: The line profile in [(m/s)\ :sup:`-1`]
+        '''
+        nu = self.nu0*(1-v/constants.c)
+        return self.phi_nu(nu)*self.nu0/constants.c
+
+    def average_over_phi_nu(self,func):
+        raise NotImplementedError
+
+
+class GaussianLineProfile(LineProfile):
+
+    """Represents a Gaussian line profile
+    
+    Attributes:
+        nu0 (:obj:`float`): rest frequency in [Hz]
+        width_nu (:obj:`float`): FWHM in [Hz]
+        width_v (:obj:`float`): FWHM in [m/s]
+    """
+
+    def initialise_phi_nu_params(self):
+        self.sigma_nu = helpers.FWHM2sigma(self.width_nu)
+        self.normalisation = 1/(self.sigma_nu*np.sqrt(2*np.pi))
+
+    def phi_nu(self,nu):
+        return self.normalisation*np.exp(-(nu-self.nu0)**2/(2*self.sigma_nu**2))
+
+    def average_over_phi_nu(self,func):
+        #choose +- 1 FWHM initially, where the Gaussian is at ~6% of the peak
+        #note that at least two iterations are done, so the final width is
+        #at least +-1.65 FWHM
+        width = 2 #units of width_nu
+        elements_per_width = 20
+        old_average = np.inf
+        residual = np.inf
+        niter = 0
+        while residual > 1e-2:
+            n_elements = int(elements_per_width*width)
+            nu = np.linspace(self.nu0-width/2*self.width_nu,
+                             self.nu0+width/2*self.width_nu,n_elements)
+            phi_nu = self.phi_nu(nu)
+            norm = np.trapezoid(y=phi_nu,x=nu)
+            new_average = np.trapezoid(y=func(nu)*phi_nu,x=nu)/norm
+            residual = helpers.relative_difference(a=np.array((new_average,)),
+                                                   b=np.array((old_average,)))
+            old_average = new_average
+            #I want to cover at least the width corresponding to the definition of
+            #overlapping lines, which is 3.14; so add 1.3 to make it 2+1.3=3.3
+            width += 1.3
+            elements_per_width += 15
+            niter += 1
+        return new_average
+
+
+class RectangularLineProfile(LineProfile):
+
+    '''Represents a rectangular line profile, i.e. constant over width_v, 0 outside'''
+
+    def initialise_phi_nu_params(self):
+        self.normalisation = 1/self.width_nu
+
+    def phi_nu(self,nu):
+        inside_line = (nu>=self.nu0-self.width_nu/2) & (nu<=self.nu0+self.width_nu/2)
+        return np.where(inside_line,self.normalisation,0)
+
+    def average_over_phi_nu(self,func):
+        #easier than Gaussian, just have to iterate over n_elements
+        #note that the func doesn't need to be constant over the line profile,
+        #so I need to have a sufficient number of elements
+        n_elements = 20
+        old_average = np.inf
+        residual = np.inf
+        while residual > 1e-2:
+            nu = np.linspace(self.nu0-self.width_nu/2,self.nu0+self.width_nu/2,
+                             n_elements)
+            phi_nu = self.phi_nu(nu)
+            norm = np.trapezoid(y=phi_nu,x=nu)
+            new_average = np.trapezoid(y=func(nu)*phi_nu,x=nu)/norm
+            residual = helpers.relative_difference(a=np.array((new_average,)),
+                                                   b=np.array((old_average,)))
+            old_average = new_average
+            n_elements += 15
+        return new_average
+
+line_profiles = {'Gaussian':GaussianLineProfile,'rectangular':RectangularLineProfile}
+
+
+class Level():
+    '''Represents an atomic / molecular level.
+
+    Attributes:
+        g (:obj:`float`): the statistical weight of the level
+        E (:obj:`float`): the energy of the level in [J]
+        number (:obj:`int`): the number of the level
+    '''
+
+    def __init__(self,g,E,number):
+        self.g = g
+        self.E = E
+        self.number = number
+
+    def LTE_level_pop(self,Z,T):
+        '''Calculates the fractional population of the level in LTE.
+
+        Args:
+            Z (:obj:`float`): The partition function.
+            T (:obj:`float`): The temperature in [K].
+        
+        Returns:
+            float: The fractional population of the level in LTE.
+        '''
+        #this is a convenience function that is not used when solving the non-LTE
+        #radiative transfer
+        return self.g*np.exp(-self.E/(constants.k*T))/Z
+
+
+class Transition():
+
+    def __init__(self,up,low):
+        self.up = up
+        self.low = low
+        self.Delta_E = self.up.E-self.low.E
+        self.name = f'{self.up.number}-{self.low.number}'
+
+    def Tex(self,x1,x2):
+        '''Computes the excitation temperature.
+        
+        Args:
+            x1: (numpy.ndarray): fractional population of the lower level
+            x2: (numpy.ndarray): fractional population of the upper level
+
+        Returns:
+            numpy.ndarray: excitation temperature in [K]
+        '''
+        return Tex(Delta_E=self.Delta_E,g_up=self.up.g,g_low=self.low.g,
+                   x1=x1,x2=x2)
+
+
+class RadiativeTransition(Transition):
+
+    r'''Represents the radiative transition between two energy levels.
+
+    Attributes:
+        up (pythonradex.atomic_transition.Level): the upper level of the 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]
+        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'
+        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)
+
+    def source_function(self,x1,x2):
+        S = np.where((x1==0) & (x2==0),0,self.A21*x2/(x1*self.B12-x2*self.B21))
+        # if np.any(S < 0):
+        #     raise RuntimeError('negative source function, potentially due to '
+        #                        +'high columndensity and/or low collider density')
+        return S
+
+
+class EmissionLine(RadiativeTransition):
+
+    r'''Represents an emission line arising from the radiative transition between
+    two levels
+    
+    Attributes:
+        up (pythonradex.atomic_transition.Level): the upper level of the 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
+            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]
+        line_profile (pythonradex.atomic_transition.LineProfile): object representing
+            the shape of the line profile
+    '''
+    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)
+        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):
+        '''Alternative constructor, taking an instance of RadiativeTransition,
+        a line profile class and the width of the line'''
+        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)
+
+    def tau_nu(self,N1,N2,nu):
+        r'''Computes the optical depth
+        
+        Args:
+            N1: (:obj:`float`): column density of molecules in the lower level
+                in [m\ :sup:`-2`]
+            N2: (:obj:`float`): column density of molecules in the upper level
+                in [m\ :sup:`-2`]
+            nu: (numpy.ndarray): frequencies in [Hz]
+
+        Returns:
+            numpy.ndarray: the optical depth at the requested frequencies
+        
+        '''
+        return tau_nu(phi_nu=self.line_profile.phi_nu(nu),N1=N1,N2=N2,nu=nu,
+                      **self.tau_kwargs)
+
+    def tau_nu0(self,N1,N2):
+        r'''Computes the optical depth at the rest frequency
+        
+        Args:
+            N1: (:obj:`float` or numpy.ndarray): column density of molecules
+                in the lower level in [m\ :sup:`-2`]
+            N2: (:obj:`float` or numpy.ndarray): column density of molecules
+                in the upper level in [m\ :sup:`-2`]
+
+        Returns:
+            float or numpy.ndarray: the optical depth at the rest frequency
+        
+        '''
+        return tau_nu(phi_nu=self.line_profile.phi_nu0,N1=N1,N2=N2,nu=self.nu0,
+                      **self.tau_kwargs)
+
+            
+class CollisionalTransition(Transition):
+
+    '''Represent the collisional transition between two energy levels
+    
+    Attributes:
+        up (pythonradex.atomic_transition.Level): the upper level of the 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
+            in [J]
+        name (:obj:`str`): name of the transition
+    ''' 
+
+    def __init__(self,up,low,K21_data,Tkin_data):
+        Transition.__init__(self,up=up,low=low)
+        assert np.all(K21_data >= 0)
+        self.K21_data = K21_data
+        self.Tkin_data = Tkin_data
+        self.Tkin_data_limits = np.min(self.Tkin_data),np.max(self.Tkin_data)
+
+    def coeffs(self,Tkin):
+        r'''
+        Computes the collisional coefficients
+
+        Args:
+            Tkin (float or numpy.ndarray): kinetic temperature in [K]
+
+        Returns:
+            tuple: The collision coefficients K12 and K21 in [m\ :sup:`3`/s]
+            at the requested temperature(s)
+
+        Raises:
+            AssertionError: 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'
+        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)
+        return [K12,K21]

pythonradex/escape_probability.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+"""
+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
+from scipy import constants
+
+
+class EscapeProbabilityUniformSphere():
+    
+    '''Represents the escape probability from a uniform spherical medium.'''
+
+    def __init__(self):
+        self.beta = escape_probability_functions.beta_uniform_sphere
+
+
+class UniformSphere(EscapeProbabilityUniformSphere):
+
+    '''Represents the escape probability and emerging flux from a uniform
+    spherical medium'''    
+    
+    @staticmethod
+    @nb.jit(nopython=True,cache=True)
+    def compute_flux_nu(tau_nu,source_function,solid_angle):
+        '''Computes the observed flux in [W/m2/Hz], given the optical depth
+        tau_nu, the source function in [W/m2/Hz/sr] and the solid angle in [sr].'''
+        #see old Osterbrock book for this formula, appendix 2
+        #this is the flux per surface of the emitting region
+        #for lower tau_nu, the Osterbrock formula becomes numerically unstable,
+        #so we use a Taylor expansion
+        min_tau_nu = 1e-2
+        stable_region = tau_nu > min_tau_nu
+        flux_nu = 2*np.pi*source_function/tau_nu**2\
+                   *(tau_nu**2/2-1+(tau_nu+1)*np.exp(-tau_nu))
+        flux_nu_Taylor = 2*np.pi*source_function*(tau_nu/3-tau_nu**2/8+tau_nu**3/30
+                          -tau_nu**4/144) #from Wolfram Alpha
+        flux_nu = np.where(stable_region,flux_nu,flux_nu_Taylor)
+        assert np.all(np.isfinite(flux_nu))
+        #the observed flux is (flux at sphere surface)*4*pi*r**2/(4*pi*d**2)
+        #=F_surface*Omega*4/(4*pi)
+        return flux_nu*solid_angle/np.pi
+
+@nb.jit(nopython=True,cache=True)
+def exp_tau_factor(tau_nu):
+    #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_nu<1e-5,tau_nu,1-np.exp(-tau_nu))
+
+
+class Flux1D():
+
+    '''Represents the computation of the flux when considering only a single direction'''
+
+    @staticmethod
+    @nb.jit(nopython=True,cache=True)
+    def compute_flux_nu(tau_nu,source_function,solid_angle):
+        '''Computes the observed flux in [W/m2/Hz], given the optical depth
+        tau_nu, the source function in [W/m2/Hz/sr] and the solid angle of
+        the source (in [sr]) seen by the observer.'''
+        tau_factor = exp_tau_factor(tau_nu=tau_nu)
+        return source_function*tau_factor*solid_angle
+
+
+class UniformSphereRADEX(EscapeProbabilityUniformSphere,Flux1D):
+    """Represents the escape probability from a uniform sphere, but uses the
+    single direction assumption to compute the emerging flux. This is what is
+    done in the original RADEX code."""
+    #see line 288 and following in io.f of RADEX
+
+    pass
+
+
+class UniformSlab(Flux1D):
+    #Since I assume the source is in the far field, it is ok to calculate the flux
+    #with the 1D formula
+    '''Represents the escape probability and emerging flux from a uniform
+    slab'''
+
+    def __init__(self):
+        self.beta = escape_probability_functions.beta_uniform_slab
+
+
+class UniformLVGSlab(Flux1D):
+    """The escape probability and flux for a uniform large velocity gradient (LVG)
+    slab"""
+
+    def __init__(self):
+        self.beta = escape_probability_functions.beta_LVG_slab
+
+
+class UniformLVGSphere():
+    """The escape probability and flux for a uniform large velocity gradient (LVG)
+    sphere"""
+
+    def __init__(self):
+        self.beta = escape_probability_functions.beta_LVG_sphere
+
+    @staticmethod
+    @nb.jit(nopython=True,cache=True)
+    def compute_flux_nu(tau_nu,source_function,solid_angle,nu,nu0,V):
+        #V is the velocity at the surface of the sphere
+        #this formula can be derived by using an approach similar to
+        #de Jong et al. (1975, Fig. 3)
+        tau_factor = exp_tau_factor(tau_nu=tau_nu)
+        v = constants.c*(1-nu/nu0)
+        return source_function*tau_factor*solid_angle*(1-(v/V)**2)
+
+
+class LVGSphereRADEX(Flux1D):
+    """The escape probability and flux for a large velocity gradient (LVG)
+    sphere (Expanding sphere in RADEX terminology), using the same
+    formula for the escape probability as the RADEX code"""
+
+    def __init__(self):
+        self.beta = escape_probability_functions.beta_LVG_sphere_RADEX