specsy 0.9.dev1__tar.gz → 0.9.dev3__tar.gz

specsy-0.9.dev3/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: specsy
+Version: 0.9.dev3
+Summary: Model fitting package for the chemical analysis of astronomical spectra
+Author-email: Vital Fernández <vgf@umich.edu>
+License-Expression: GPL-3.0-or-later
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: arviz~=0.23.4
+Requires-Dist: corner~=2.2
+Requires-Dist: h5netcdf~=1.3.0
+Requires-Dist: jax~=0.9.2
+Requires-Dist: jaxlib~=0.9.2
+Requires-Dist: aspect-stable~=0.7.dev2
+Requires-Dist: lime-stable~=2.2.dev5
+Requires-Dist: innate-stable~=0.2.2
+Requires-Dist: pymc~=5.28
+Requires-Dist: toml~=0.10
+Requires-Dist: xarray~=2026.2.0
+Provides-Extra: tensors
+Requires-Dist: pytensor~=2.38.2; extra == "tensors"
+Requires-Dist: blackjax~=1.5; extra == "tensors"
+Requires-Dist: numba~=0.65.1; extra == "tensors"
+Requires-Dist: numpyro~=0.21.0; extra == "tensors"
+Requires-Dist: nutpie~=0.16.8; extra == "tensors"
+Provides-Extra: docs
+Requires-Dist: sphinx-rtd-theme~=3.0; extra == "docs"
+Requires-Dist: ipympl~=0.9; extra == "docs"
+Requires-Dist: myst-nb~=1.3; extra == "docs"
+Provides-Extra: tests
+Requires-Dist: pytest~=8.4; extra == "tests"
+Requires-Dist: pytest-cov~=7.0; extra == "tests"
+Requires-Dist: pytest-mpl~=0.17; extra == "tests"
+
+# Specsy
+
+<p align="center">
+  <img src="https://github.com/Vital-Fernandez/specsy/blob/7e35568f6d154486f5603e94fe39dd08e5e54834/src/specsy/resources/images/Specsy_logo_transparent_dark.PNG" alt="Specsy Logo" width="300"/>
+</p>
+
+A Python library for the analysis of astronomical spectra. Specsy includes a Bayesian sampler for the
+direct method parameter space, tools to fit photoionization model grids, and utilities for the analysis
+of stellar and gas continua.
+
+> **Note:** This package is currently in an alpha release. The preliminary documentation can be found at [ReadTheDocs](https://specsy.readthedocs.io/).
+
+## Installation
+
+Install directly from [PyPI](https://pypi.org/project/specsy/):
+
+```bash
+pip install specsy
+```
+
+For the recommended conda environment with PyMC sampler backends:
+
+```bash
+conda create -c conda-forge -n specsy python=3.13 nutpie pymc numba numpyro blackjax
+conda activate specsy
+pip install specsy
+```
+
+To upgrade to the latest version:
+
+```bash
+pip install --upgrade specsy
+```
+
+## Development
+
+SpecSy is currently in an alpha release. Please check the [GitHub repository](https://github.com/Vital-Fernandez/specsy)
+for the latest version or to report any issues.
+
+**Author:** Vital Fernández — [vgf@stsci.edu](mailto:vgf@stsci.edu)

specsy-0.9.dev3/README.md

@@ -0,0 +1,40 @@
+# Specsy
+
+<p align="center">
+  <img src="https://github.com/Vital-Fernandez/specsy/blob/7e35568f6d154486f5603e94fe39dd08e5e54834/src/specsy/resources/images/Specsy_logo_transparent_dark.PNG" alt="Specsy Logo" width="300"/>
+</p>
+
+A Python library for the analysis of astronomical spectra. Specsy includes a Bayesian sampler for the
+direct method parameter space, tools to fit photoionization model grids, and utilities for the analysis
+of stellar and gas continua.
+
+> **Note:** This package is currently in an alpha release. The preliminary documentation can be found at [ReadTheDocs](https://specsy.readthedocs.io/).
+
+## Installation
+
+Install directly from [PyPI](https://pypi.org/project/specsy/):
+
+```bash
+pip install specsy
+```
+
+For the recommended conda environment with PyMC sampler backends:
+
+```bash
+conda create -c conda-forge -n specsy python=3.13 nutpie pymc numba numpyro blackjax
+conda activate specsy
+pip install specsy
+```
+
+To upgrade to the latest version:
+
+```bash
+pip install --upgrade specsy
+```
+
+## Development
+
+SpecSy is currently in an alpha release. Please check the [GitHub repository](https://github.com/Vital-Fernandez/specsy)
+for the latest version or to report any issues.
+
+**Author:** Vital Fernández — [vgf@stsci.edu](mailto:vgf@stsci.edu)

{specsy-0.9.dev1 → specsy-0.9.dev3}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsy"
-version = "0.9.dev1"
-readme = "README.rst"
+version = "0.9.dev3"
+readme = "README.md"
 requires-python = ">=3.11"
 license = "GPL-3.0-or-later"
 authors = [{name = "Vital Fernández", email = "vgf@umich.edu"}]
@@ -15,9 +15,9 @@ dependencies = ["arviz~=0.23.4",
                 "h5netcdf~=1.3.0",
                 "jax~=0.9.2",
                 "jaxlib~=0.9.2",
-                "aspect-stable~=0.7.dev1",
-                "lime-stable~=2.2.dev1",
-                "innate-stable~=0.2.1",
+                "aspect-stable~=0.7.dev2",
+                "lime-stable~=2.2.dev5",
+                "innate-stable~=0.2.2",
                 "pymc~=5.28",
                 "toml~=0.10",
                 "xarray~=2026.2.0"]
@@ -26,7 +26,11 @@ classifiers = ["Programming Language :: Python :: 3",
                "Programming Language :: Python :: 3.11"]
 
 [project.optional-dependencies]
-tensors = ["pytensor~=2.38.2"]
+tensors = ["pytensor~=2.38.2",
+           "blackjax~=1.5",
+           "numba~=0.65.1",
+           "numpyro~=0.21.0",
+           "nutpie~=0.16.8"]
 
 docs = ["sphinx-rtd-theme~=3.0",
         "ipympl~=0.9",
@@ -43,3 +47,7 @@ mpl-baseline-path = 'tests/baseline'
 mpl-results-path = 'tests/outputs'
 mpl-results-always = false
 addopts = "-p no:asdf_schema_tester"
+
+[tool.setuptools.package-data]
+specsy = ["resources/data/*",
+          "resources/images/*"]

{specsy-0.9.dev1 → specsy-0.9.dev3}/src/specsy/__init__.py

@@ -23,5 +23,7 @@ __version__ = _setup_cfg['metadata']['version']
 from lime import load_cfg as load_cfg, load_frame as load_frame, Line as Line, lines_frame as lines_frame, save_frame as save_frame
 from lime import Spectrum as Spectrum, Cube as Cube
 from innate import load_dataset as load_dataset
+from specsy.io import specsy_cfg as cfg
 from specsy.observations import Nebula
-from specsy.models.extinction import extinction_coeff_calc
+from specsy.models.extinction import extinction_coeff_calc
+from specsy.plotting.plots import theme

{specsy-0.9.dev1 → specsy-0.9.dev3}/src/specsy/io.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import numpy as np
 import configparser
@@ -5,6 +6,10 @@ from pathlib import Path
 from collections.abc import Sequence
 from astropy.io import fits
 from innate import load_dataset
+from lime import load_cfg
+
+_logger = logging.getLogger('SpecSy')
+
 
 FITS_INPUTS_EXTENSION = {'lines_list': '20A', 'line_fluxes': 'E', 'line_err': 'E'}
 
@@ -16,6 +21,9 @@ FITS_OUTPUTS_EXTENSION = {'parameter_list': '20A',
                           'p84th': 'E',
                           'true': 'E'}
 
+# Load lime configuration
+_cfg_file_path = Path(__file__).parent/'specsy.toml'
+specsy_cfg = load_cfg(_cfg_file_path)
 
 class SpecSyError(Exception):
     """SpecSy exception function"""

specsy-0.9.dev3/src/specsy/models/__init__.py

@@ -0,0 +1,2 @@
+from specsy.models.nebular_continuum import NebularContinua
+from specsy.models.literature import TEM_FUNC_DICT, DEN_FUNC_DICT

{specsy-0.9.dev1 → specsy-0.9.dev3}/src/specsy/models/chemistry.py

@@ -2,19 +2,20 @@ import logging
 import warnings
 from dataclasses import dataclass
 
+import lime
 import numpy as np
 import arviz as az
 import xarray as xr
 from lime import label_decomposition, Line, lines_frame, normalize_fluxes
-
+from pathlib import Path
 from innate import load_dataset
 
-from specsy import _setup_cfg
-from specsy.io import SpecSyError
+from specsy.io import SpecSyError, specsy_cfg
 from specsy.tools import truncated_gaussian, flux_distribution
 from specsy.operations.interpolation import compile_bilinear_interp
 from specsy.models.extinction import flambda_calc
-from specsy.models.literature import _TEM_FUNC_DICT, _DEN_FUNC_DICT
+from specsy.models.literature import TEM_FUNC_DICT, DEN_FUNC_DICT
+from specsy.models.fluxes_line import DEFAULT_PARTICLE_EQUATIONS_KEYS, FLUX_EQUATION_DICT
 from specsy.sampler import direct_method_multi_region, run_model
 from matplotlib import pyplot as plt
 
@@ -272,17 +273,52 @@ def package_results(fname, inference_data, inputs=None, prior_dict=None, true_va
     return
 
 
-@dataclass
 class InputsDirectMethod:
-    labels: np.ndarray
-    flux_arr: np.ndarray
-    err_arr: np.ndarray
-    flambda_arr: np.ndarray
-    ion_arr: np.ndarray
-    temp_id_arr: np.ndarray
-    den_id_arr: np.ndarray
-    eq_tem_arr: np.ndarray
-    eq_den_arr: np.ndarray
+
+    def __init__(self, input_lines, input_flux, input_err, flambda_arr, ion_arr,
+                 temp_id_arr, den_id_arr, tem_eq_arr, den_eq_arr, eq_flux_arr,):
+
+        self.labels  = input_lines
+        self.flux_arr   = input_flux
+        self.err_arr    = input_err
+        self.flambda_arr  = flambda_arr
+        self.ion_arr      = ion_arr
+        self.temp_id_arr  = temp_id_arr
+        self.den_id_arr   = den_id_arr
+        self.eq_tem_arr   = tem_eq_arr
+        self.eq_den_arr   = den_eq_arr
+        self.eq_flux_arr   = eq_flux_arr
+
+    @classmethod
+    def from_dataframe(cls, lines_structure):
+
+        # Remove normalization line
+        if 'norm_line' in lines_structure.columns:
+            idcs = ~lines_structure.index.isin(lines_structure['norm_line'].unique())
+        else:
+            idcs = np.ones(lines_structure.index.size).astype(bool)
+
+        # Line inputs the data
+        input_lines = lines_structure.loc[idcs].index.to_numpy()
+        input_flux  = lines_structure.loc[idcs].line_flux.to_numpy()
+        input_err   = lines_structure.loc[idcs].line_flux_err.to_numpy()
+
+        # Unpack physical parameters
+        flambda_arr = lines_structure.loc[idcs].f_lambda.to_numpy()
+        ion_arr     = lines_structure.loc[idcs].particle.to_numpy()
+
+        # Unpack the temp/den structure arrays
+        temp_id_arr = lines_structure.loc[idcs].temp.to_numpy()
+        den_id_arr  = lines_structure.loc[idcs].den.to_numpy()
+        tem_eq_arr  = lines_structure.loc[idcs].eq_temp.to_numpy()
+        den_eq_arr  = lines_structure.loc[idcs].eq_den.to_numpy()
+        eq_flux_arr  = lines_structure.loc[idcs].eq_flux.to_numpy()
+
+        print(f'Multi-region direct method sampler')
+        print(f'- Readying inputs:')
+
+        return cls(input_lines, input_flux, input_err, flambda_arr, ion_arr,
+                   temp_id_arr, den_id_arr, tem_eq_arr, den_eq_arr, eq_flux_arr)
 
 
 class DirectMethod:
@@ -290,7 +326,7 @@ class DirectMethod:
     def __init__(self, lines_df, ion_struct):
 
         # Default prior cfg
-        self.prior_cfg = _setup_cfg['direct_method_priors']
+        self.prior_cfg = specsy_cfg['direct_method_priors']
 
         # Default emissivity
         self.emis_interp = None
@@ -310,43 +346,70 @@ class DirectMethod:
 
         return
 
-    def prepare_inputs(self, emissivity_source=None, prior_cfg=None, R_V=3.1, law='G03 LMC',
-                       norm_list='H1_4861A', normalize_flux=True, line_list=None, flux_column='profile_flux'):
+    def prepare_inputs(self, line_list=None, emissivity_source=None, prior_cfg=None, kinematic_component=0,
+                       R_V=3.1, law='G03 LMC', norm_line='H1_4861A', normalize_flux=True, flux_column='profile_flux',
+                       review_model=True):
 
         # Check the lines frame and normalization line
         if self._lines_frame is None:
             raise SpecSyError(f'The object does not have a lines_frame declared')
 
-        self.norm_line = norm_list
+        self.norm_line = norm_line
         if self.norm_line not in self._lines_frame.index:
             raise SpecSyError(f'The normalization line "{self.norm_line}" is not in the input lines frame')
 
         # Prepare the emissivity interpolator
-        emis_dataset = load_dataset(emissivity_source)
+        if isinstance(emissivity_source, (str, Path)):
+            emis_dataset = load_dataset(emissivity_source)
+        else:
+            emis_dataset = emissivity_source
         self.emis_interp = compile_bilinear_interp(emis_dataset)
 
         # Prepare the prior cfg
         self.prior_cfg = self.prior_cfg if prior_cfg is None else prior_cfg
 
+        # Select the lines
+        if line_list is None:
+            self.lines_structure = self._lines_frame.copy()
+        else:
+            self.lines_structure = self._lines_frame.loc[self._lines_frame.index.isin(line_list)].copy()
+
+        # Remove the kinematic components
+        if kinematic_component == 0:
+            idcs_kinem = ~self.lines_structure.index.str.contains('_k-')
+        else:
+            idcs_kinem = self.lines_structure.index.contains(f'_k-{kinematic_component}')
+        self.lines_structure = self.lines_structure.loc[idcs_kinem]
+
         # Make a copy of the frame and normalize the fluxes
         if normalize_flux:
-            self.lines_structure = normalize_fluxes(self._lines_frame.copy(), line_list=line_list, norm_list=norm_list, flux_column=flux_column, clear_empty=True)
+            self.lines_structure = normalize_fluxes(self.lines_structure, norm_list=norm_line, flux_column=flux_column,
+                                                    clear_empty=True)
         else:
-            self.lines_structure = self._lines_frame.copy()
+            self.lines_structure.insert(3, 'norm_line', self.norm_line)
 
         # Compute the reddening law
         flambda_arr = flambda_calc(self.lines_structure.wavelength, R_V, law, self.lines_structure.loc['H1_4861A'].wavelength)
-        self.lines_structure.insert(3, 'f_lambda', flambda_arr)
+        if 'f_lambda' not in self.lines_structure.columns:
+            self.lines_structure.insert(4, 'f_lambda', flambda_arr)
 
         # Map the target lines to the ionization structure
-        self.lines_structure = self.ion_struct.map_line_structure(self.lines_structure, norm_line=self.norm_line)
+        self.lines_structure = self.ion_struct.map_line_structure(self.lines_structure)
+
+        # Add the equations per ion
+        if 'eq_flux' not in self.lines_structure.columns:
+            self.lines_structure.insert(9, 'eq_flux', '-')
+        for line_label in self.lines_structure.index:
+            eq_name = DEFAULT_PARTICLE_EQUATIONS_KEYS.get(self.lines_structure.at[line_label, 'particle'], 'metals')
+            self.lines_structure.loc[line_label, 'eq_flux'] = eq_name
 
         # Check for issues
-        self._review_inputs()
+        if review_model:
+            self._review_inputs()
 
         return
 
-    def _review_inputs(self):
+    def _review_inputs(self, return_message=False):
 
         errors = []
         no_dash = self.lines_structure['region'] != '-'
@@ -364,7 +427,7 @@ class DirectMethod:
                 errors.append(f"'{col}' is '-' for non-'-' region rows at lines: {bad}")
 
         # 3) eq_temp / eq_den values must be keys in their respective dicts
-        for col, d in (('eq_temp', _TEM_FUNC_DICT), ('eq_den', _DEN_FUNC_DICT)):
+        for col, d in (('eq_temp', TEM_FUNC_DICT), ('eq_den', DEN_FUNC_DICT)):
             mask = self.lines_structure[col] != '-'
             bad = self.lines_structure.index[mask & ~self.lines_structure[col].isin(d)].tolist()
             if bad:
@@ -380,64 +443,61 @@ class DirectMethod:
         # 5) Check if we have emissivity data
         bad = [idx for idx in self.lines_structure.index if idx not in self.emis_interp]
         if bad:
-            errors.append(f"Line emissivity not available in the input file: {bad}")
-
-        if errors:
-            msg = "lines_structure validation failed:\n" + "\n".join(f"  - {e}" for e in errors)
-            warnings.warn(msg)
-            raise ValueError(msg)
+            errors.append(f"Missing emissivity data for transitions: {bad}")
 
-    def run(self):
+        # 6) Check the flux equation is recognized
+        eq_flux_names = self.lines_structure.eq_flux.unique()
+        bad = [eq_name for eq_name in eq_flux_names if eq_name not in FLUX_EQUATION_DICT]
+        if bad:
+            errors.append(f"Flux equation not available in database for: {bad}")
 
-        # Line inputs the data
-        input_lines = self.lines_structure.index.to_numpy()
-        input_flux = self.lines_structure.line_flux.to_numpy()
-        input_err = self.lines_structure.line_flux_err.to_numpy()
+        if not return_message:
+            if errors:
+                msg = "lines_structure validation failed:\n" + "\n".join(f"  - {e}" for e in errors)
+                warnings.warn(msg)
+                raise ValueError(msg)
+            else:
+                return None
+        else:
+            return errors
 
-        # Unpack physical parameters
-        flambda_arr = self.lines_structure.f_lambda.to_numpy()
-        ion_arr = self.lines_structure.particle.to_numpy()
 
-        # Unpack the temp/den structure arrays
-        temp_id_arr = self.lines_structure.temp.to_numpy()
-        den_id_arr = self.lines_structure.den.to_numpy()
-        tem_eq_arr = self.lines_structure.eq_temp.to_numpy()
-        den_eq_arr = self.lines_structure.eq_den.to_numpy()
+    def run(self, draws=1000, tune=2000, chains=8, cores=8, target_accept=0.8, nuts_sampler='numpyro', callback=None,
+            linear_scale_results=True):
 
-        # Inputs object
-        print(f'Multi-region direct method sampler')
-        print(f'- Readying inputs:')
-        self.inputs = InputsDirectMethod(input_lines, input_flux, input_err, flambda_arr, ion_arr,
-                                         temp_id_arr, den_id_arr, tem_eq_arr, den_eq_arr)
+        # Input data
+        self.inputs = InputsDirectMethod.from_dataframe(self.lines_structure)
 
         # Create the model
         print(f'- Compiling model:')
         self.model = direct_method_multi_region(inputs=self.inputs, emis_interp=self.emis_interp, prior_dict=self.prior_cfg,
-                                                tem_EQDB=_TEM_FUNC_DICT, den_EQDB=_DEN_FUNC_DICT)
+                                                tem_EQDB=TEM_FUNC_DICT, den_EQDB=DEN_FUNC_DICT)
 
         # Run the model
         print(f'- Launching sampler:')
-        self.trace = run_model(self.model)
+        self.trace = run_model(self.model,  draws=draws, tune=tune, chains=chains, cores=cores, target_accept=target_accept,
+                               nuts_sampler=nuts_sampler, callback=callback)
+
+        # Remove the normalization from the fluxes
+        if linear_scale_results:
+            self.trace.posterior['theo_flux'] = np.power(10, self.trace.posterior['theo_flux'])
+            self.trace.observed_data['likelihood'] = np.power(10, self.trace.observed_data['likelihood'])
+
+        # Remove the log scale for the helium abundaces
+        for helium in ['He1', 'He2']:
+            if helium in self.inputs.ion_arr:
+                self.trace.posterior[helium] = np.power(10, self.trace.posterior[helium])
 
         return
 
-    def save_trace(self, fname):
+    def save_line_structure(self, fname):
+        lime.save_frame(fname, self.lines_structure)
 
-        # Save with arviz formating
+        return
+
+    def save_trace(self, fname):
         az.to_netcdf(self.trace, fname)
-        # results_dict = pack_results(fname)
-        # save_dataset(fname, results_dict)
 
         return
 
-    def plot_trace(self, var_names = ["O2", "O3", "S2", "S3", "N2", "Ar3", "cHBeta", "den_low", "temp_low",
-                                      "temp_high"]):
-        # var_names = ["O2", "O3", "S2", "S3", "N2", "Ar3", "Ar4", "Ne3", "cHBeta", "den_low", "temp_low",
-        #              "temp_high"]
-        az.plot_pair(self.trace, var_names=var_names, divergences=True)
-        az.plot_posterior(self.trace, var_names=var_names)
-        summary = az.summary(self.trace, var_names=var_names)
-        print(summary)
-        plt.show()
 
-        return

{specsy-0.9.dev1 → specsy-0.9.dev3}/src/specsy/models/chemistry_inference.py

@@ -4,7 +4,7 @@ from pandas import unique
 from pytensor import tensor as tt
 from arviz import to_netcdf
 
-from specsy.models.literature import _TEM_FUNC_DICT, _DEN_FUNC_DICT
+from specsy.models.literature import TEM_FUNC_DICT, DEN_FUNC_DICT
 from lime.io import check_file_dataframe
 
 def storeValueInTensor(idx, value, tensor1D):
@@ -244,8 +244,8 @@ def direct_method_multi_region(lines_df, emis_interp, prior_dict, fname=None):
         for i in range_arr:
 
             # Compute the emissivity
-            tem = dm_model[Tem_label_arr[i]] if temp_eq_check[i] else _TEM_FUNC_DICT[tem_eq_arr[i]](dm_model[Tem_label_arr[i]])
-            den = dm_model[den_label_arr[i]] if den_eq_check[i] else _DEN_FUNC_DICT[den_eq_arr[i]](dm_model[den_label_arr[i]])
+            tem = dm_model[Tem_label_arr[i]] if temp_eq_check[i] else TEM_FUNC_DICT[tem_eq_arr[i]](dm_model[Tem_label_arr[i]])
+            den = dm_model[den_label_arr[i]] if den_eq_check[i] else DEN_FUNC_DICT[den_eq_arr[i]](dm_model[den_label_arr[i]])
             emis = emis_interp[line_arr[i]](tem, den)
 
             if particle_arr[i] == 'H1':

{specsy-0.9.dev1 → specsy-0.9.dev3}/src/specsy/models/fluxes_line.py

@@ -1,4 +1,23 @@
-from pytensor import tensor as tt, function
+import pytensor
+
+
+def H1_flux(abund, emis, flambda, cHbeta):
+    return emis - flambda * cHbeta
+
+
+def helium_flux(abund, emis, flambda, cHbeta):
+    return abund + emis - flambda * cHbeta
+
+
+def metals_flux(abund, emis, flambda, cHbeta):
+    return abund + emis - flambda * cHbeta - 12
+
+
+FLUX_EQUATION_DICT = {'hydrogen':   H1_flux,
+                      'helium':     helium_flux,
+                      'metals':     metals_flux}
+
+DEFAULT_PARTICLE_EQUATIONS_KEYS = {'H1': 'hydrogen', 'He1': 'helium', 'He2': 'helium'}
 
 
 class EmissionFluxModel:
@@ -80,9 +99,9 @@ class EmissionFluxModel:
         return abund + emis_ratio - flambda * cHbeta - 12
 
     def ion_O2_7319A_b_flux_log(self, emis_ratio, cHbeta, flambda, abund, ftau, O3, T_high):
-        col_ext = tt.power(10, abund + emis_ratio - flambda * cHbeta - 12)
-        recomb = tt.power(10, O3 + 0.9712758 + tt.log10(tt.power(T_high/10000.0, 0.44)) - flambda * cHbeta - 12)
-        return tt.log10(col_ext + recomb)
+        col_ext = pytensor.tensor.power(10, abund + emis_ratio - flambda * cHbeta - 12)
+        recomb = pytensor.tensor.power(10, O3 + 0.9712758 + pytensor.tensor.log10(pytensor.tensor.power(T_high / 10000.0, 0.44)) - flambda * cHbeta - 12)
+        return pytensor.tensor.log10(col_ext + recomb)
 
 
 class EmissionTensors(EmissionFluxModel):
@@ -100,9 +119,9 @@ class EmissionTensors(EmissionFluxModel):
 
         # Compile the theano functions for all the input emission lines
         for label, func in self.emFluxEqDict.items():
-            func_params = tt.dscalars(self.emFluxParamDict[label])
-            self.emFluxEqDict[label] = function(inputs=func_params, outputs=func(*func_params),
-                                                on_unused_input='ignore')
+            func_params = pytensor.tensor.dscalars(self.emFluxParamDict[label])
+            self.emFluxEqDict[label] = pytensor.function(inputs=func_params, outputs=func(*func_params),
+                                                         on_unused_input='ignore')
 
         # Assign function dictionary with flexible arguments
         self.assign_flux_eqtt()