PyESPER 1.0.0__py3-none-any.whl

PyESPER/lir_uncertainties.py

@@ -0,0 +1,99 @@
+def process_uncertainties(param, default_factor, MeasUncerts, PredictorMeasurements, n):
+   
+    """ 
+  Helps proces uncertainties as needed by formatting any possible inputs, calculating
+        outputs, and processing "nan" values
+
+    Inputs:
+        param: String name of uncertainty to be calculated
+        default_factor: Scalar default uncertainty value
+        MeasUncerts: Dictionary of measurement uncertainty values
+        PredictorMeasurements: Dictionary of input measurements
+        n: Scalar number of estimates
+
+    Ouputs:
+        result: Numpy array of user uncertainty-based uncertainties for each param
+        dresult: Numpy array of default uncertainties for each param
+    """
+    
+    import numpy as np
+
+   # Determining whether the defined seawater property uncertainty has been used as input
+    if param in MeasUncerts:
+        # Obtain the predefined uncertainty if provided
+        result = np.array(MeasUncerts.get(param))
+        # Determining if unique uncertainties for each measurement were provided of if
+        # only one uncertainty per property was given for all properties, and formatting
+        # to the same length if so
+        if len(result) < n:
+            result = np.tile(result, n)
+        # Formatting the naming convention of default uncertainties
+        if param.replace('_u', '') in PredictorMeasurements:
+            dresult = np.array([i * default_factor for i in PredictorMeasurements[param.replace('_u', '')]])
+        else:
+            dresult = result
+    # Giving defaults in the case where user-provided uncertainties were not provided
+    else:
+        if param.replace('_u', '') in PredictorMeasurements:
+            result = np.array([i * default_factor for i in PredictorMeasurements[param.replace('_u', '')]])
+            dresult = result
+        else:
+            result = np.tile('nan', n)
+            dresult = np.tile(0, n)
+    return result, dresult
+
+def measurement_uncertainty_defaults(n, PredictorMeasurements={}, MeasUncerts={}):
+    
+    """
+    Inputs:
+        n: Scalar number of estimates requested
+        PredictorMeasurements: Dictionary of predictor measurements used for analyses
+        MeasUncerts: User-provided measurement uncertainties or empty dictionary, if not provided
+            
+    Outputs:
+        Uncertainties_pre: Dictionary of user-provided measurement uncertainties
+        DUncertainties_pre: Dictionary of default measurement uncertainties
+    """
+    
+    import numpy as np
+
+    Uncertainties_pre, DUncertainties_pre = {}, {}
+            
+    # User-input salinity measurement uncertainties
+    sal_u = np.array(MeasUncerts.get("sal_u", [0.003]))
+    sal_u = np.tile(sal_u, n) if len(sal_u) < n else sal_u
+    # Default salinity measurement uncertainties
+    sal_defu = np.tile(0.003, n)
+    
+    # User-defined and default temperature measurement uncertainties
+    temp_u = np.tile(np.array(MeasUncerts.get("temp_u", [0.003])), n) if "temp_u" in MeasUncerts or "temperature" in PredictorMeasurements else np.tile("nan", n)
+    temp_defu = np.tile(0.003 if "temp_u" in MeasUncerts or "temperature" in PredictorMeasurements else 0, n)
+    
+    # Process other parameters
+    parameters = {
+        "phosphate_u": 0.02,
+        "nitrate_u": 0.02,
+        "silicate_u": 0.02,
+        "oxygen_u": 0.01
+    }
+        
+    # User process_uncertainties function to calculate defaults and user-defined uncertainties for each
+    # parameter in a dictionary
+    for param, factor in parameters.items():
+        Uncertainties_pre[param], DUncertainties_pre[param] = process_uncertainties(
+            param,
+            factor,
+            MeasUncerts,
+            PredictorMeasurements,
+            n
+        )
+    
+    # Update MeasUncerts and DefaultUAll dictionary keys to include salinity, temperature, and all other properties
+    meas_uncerts_keys = ["sal_u", "temp_u", *parameters.keys()]
+    
+    # Populating the dictionaries
+    Uncertainties_pre.update(dict(zip(meas_uncerts_keys, [sal_u, temp_u, *Uncertainties_pre.values()])))
+    DUncertainties_pre.update(dict(zip(meas_uncerts_keys, [sal_defu, temp_defu, *DUncertainties_pre.values()])))
+    
+    return Uncertainties_pre, DUncertainties_pre
+

PyESPER/mixed.py

@@ -0,0 +1,37 @@
+def mixed(DesiredVariables, Path, OutputCoordinates={}, PredictorMeasurements={}, **kwargs):
+    
+    """
+    Python interpretation of ESPER_Mixedv1.1
+
+    Empirical Seawater Property Estimation Routines: Estimates seawater properties and estimate uncertainty from combinations of other parameter
+    measurements.  PYESPER_Mixed refers specifically to code that averages estunated from PyESPER_NN and PyESPER_LIR. See either subfunction for
+    comments. The input arguments are the same for this function and for both subfunctions.
+    
+    *************************************************************************
+    Please send questions or related requests about PyESPER to lmdias@uw.edu.
+    ************************************************************************* 
+    """
+    import time
+    import numpy as np
+    from .lir import lir
+    from .nn import nn
+    
+    tic = time.perf_counter()
+
+    # Fetch estimates and uncertainties from PyESPER_LIR and PyESPER_NN
+    EstimatesLIR, _, UncertaintiesLIR = lir(DesiredVariables, Path, OutputCoordinates, PredictorMeasurements, **kwargs)
+    EstimatesNN, UncertaintiesNN = nn(DesiredVariables, Path, OutputCoordinates, PredictorMeasurements, **kwargs)
+
+    Estimates, Uncertainties = {}, {}
+    for est_type in EstimatesLIR.keys():
+        estimates_lir = np.array(EstimatesLIR[est_type])
+        estimates_nn = np.array(EstimatesNN[est_type])
+        uncertainties_lir = np.array(UncertaintiesLIR[est_type])
+        uncertainties_nn = np.array(UncertaintiesNN[est_type])
+        Estimates[est_type] = np.mean([estimates_lir, estimates_nn], axis=0).tolist()
+        Uncertainties[est_type] = np.minimum(uncertainties_lir, uncertainties_nn).tolist()
+
+    toc = time.perf_counter()
+    print(f"PyESPER_Mixed took {toc - tic:0.4f} seconds, or {(toc-tic)/60:0.4f} minutes to run")    
+
+    return Estimates, Uncertainties

PyESPER/nn.py

@@ -0,0 +1,134 @@
+def nn(DesiredVariables, Path, OutputCoordinates={}, PredictorMeasurements={}, **kwargs):
+
+    """
+    Neural networks for seawater property estimation as part of PyESPERsv1.0.0
+
+    Inputs: 
+        DesiredVariables: list of desired variables to estimate
+        Path: User-defined computer path
+        OutputCoordinates: List of coordinates to produce estimates for
+        PredictorMeasurements: List of predictor measurements to use in NNs
+        **kwargs: Optional inputs specific to users (please see README for full description)
+
+    Outputs:
+        Estimates: Dictionary of estimates for each equation-desired variable combination
+        Uncertainties: Dictionary of uncertainties for each equation-desired variable combination
+    """
+
+    import time
+    from PyESPER.errors import errors
+    from PyESPER.defaults import defaults
+    from PyESPER.lir_uncertainties import measurement_uncertainty_defaults
+    from PyESPER.inputdata_organize import inputdata_organize
+    from PyESPER.temperature_define import temperature_define
+    from PyESPER.iterations import iterations
+    from PyESPER.fetch_polys_NN import fetch_polys_NN
+    from PyESPER.define_polygons import define_polygons
+    from PyESPER.run_nets import run_nets
+    from PyESPER.process_netresults import process_netresults
+    from PyESPER.organize_nn_output import organize_nn_output
+    from PyESPER.pH_DIC_nn_adjustment import pH_DIC_nn_adjustment
+    from PyESPER.final_formatting import final_formatting
+
+    # Starting the timer 
+    tic = time.perf_counter()
+    
+    # Function that provides custom error messages for erroneous inputs
+    errors(OutputCoordinates, PredictorMeasurements)
+
+    # Function which calculates default measurement uncertainties
+    Equations, n, VerboseTF, EstDates, C, PerKgSwTF, MeasUncerts = defaults(
+        DesiredVariables,
+        PredictorMeasurements,
+        OutputCoordinates,
+        **kwargs
+    )
+
+    # Function that processes the input values and default uncertainties and makes sense of it
+    Uncertainties_pre, DUncertainties_pre = measurement_uncertainty_defaults(
+        n,
+        PredictorMeasurements,
+        MeasUncerts
+    )
+
+    # Creating a dictionary of input data
+    InputAll = inputdata_organize(
+        EstDates,
+        C,
+        PredictorMeasurements,
+        Uncertainties_pre
+    )
+
+    # Defining temperature if not provided in the correct format
+    PredictorMeasurements, InputAll = temperature_define(
+        DesiredVariables, 
+        PredictorMeasurements,
+        InputAll,
+        **kwargs
+    )
+
+    # Iterating through possible variable-equation combinations 
+    # to produce a usable dictionary of predictor values
+    code, unc_combo_dict, dunc_combo_dict = iterations(
+        DesiredVariables,
+        Equations,
+        PerKgSwTF,
+        C,
+        PredictorMeasurements,
+        InputAll,
+        Uncertainties_pre,
+        DUncertainties_pre
+    )
+
+    # Creating boolean indicators for different ocean regions
+    df = define_polygons(C)
+
+    # Running the actual neural nets
+    EstAtl, EstOther = run_nets(
+        DesiredVariables, 
+        Equations, 
+        code
+    )
+
+    # Processing and organizing results from nets, including regional
+    # smoothing based on boolean indicators
+    Estimates = process_netresults(
+        Equations, 
+        code, 
+        df, 
+        EstAtl, 
+        EstOther
+    )
+
+    # Organize output and iteratively calculate uncertainties
+    Uncertainties = organize_nn_output(
+        Path,
+        DesiredVariables,
+        OutputCoordinates,
+        PredictorMeasurements,
+        **kwargs
+    )
+
+    # Adjust pH and DIC for anthropogenic carbon
+    YouHaveBeenWarnedCanth=False
+    Cant_adjusted = pH_DIC_nn_adjustment(
+        Path,
+        DesiredVariables, 
+        Estimates,
+        YouHaveBeenWarnedCanth,
+        OutputCoordinates,
+        PredictorMeasurements,
+        **kwargs
+    )
+    
+    # Final formatting and presentation of code
+    Estimates = final_formatting(
+        DesiredVariables,
+        Cant_adjusted,
+        Estimates
+    )
+       
+    toc = time.perf_counter()
+    print(f"PyESPER_NN took {toc - tic:0.4f} seconds, or {(toc-tic)/60:0.4f} minutes to run")
+
+    return Estimates, Uncertainties

PyESPER/organize_data.py

@@ -0,0 +1,378 @@
+def organize_data(
+    aaLCs, 
+    elLCs, 
+    aaInterpolants_pre, 
+    elInterpolants_pre, 
+    Gdf={}, 
+    AAdata={},
+    Elsedata={}
+    ):
+
+    """
+    Organize interpolation output into more usable formatting and compute estimates
+
+    Inputs:
+        aaLCs: List of coefficients for input data from Atlantic/Arctic regions
+        elLCs: List of coefficients for input data not from Atlantic/Arctic
+        aaInterpolants_pre: Scipy interpolant for Atlantic/Arctic
+        elInterpolants_pre: Scipy interpolant for not Atlantic/Arctic
+        Gdf: Dictionary of grid for interpolation, separated into regions
+        AAdata: Dictionary of user input data for Atlantic/Arctic
+        ElseData: Dictionary of user input data not for Atlantic/Arctic
+
+    Outputs:
+        Estimate: Dictionary of estimates for each equation-desired variable combination
+        CoefficientsUsed: Dictionary of dictionaries of coefficients for each equation-
+            desired variable combination
+    """
+
+    import numpy as np
+
+    # Determine combinations
+    Gkeys = list(Gdf.keys())
+
+    AAOvalues, ElseOvalues = list(AAdata.values()), list(Elsedata.values())
+    # Initialize lists for storing interpolated values
+    aaIntCT2, aaIntCA2, aaIntCB2, aaIntCC2, aaTo2, aaAo2, aaBo2, aaCo2 = [[] for _ in range(8)]
+    elIntCT2, elIntCA2, elIntCB2, elIntCC2, elTo2, elAo2, elBo2, elCo2 = [[] for _ in range(8)]
+    aaInterpolants, elInterpolants = {}, {}
+
+    # Separate out stored values
+    for i in range(0, len(aaLCs)):
+        aaIntalpha, elIntalpha = aaLCs[i][:, 0], elLCs[i][:, 0]
+        aaIntCS, elIntCS = aaLCs[i][:, 1], elLCs[i][:, 1]
+        aaIntCT, elIntCT = aaLCs[i][:, 2], elLCs[i][:, 2]
+        aaIntCA, elIntCA = aaLCs[i][:, 3], elLCs[i][:, 3]
+        aaIntCB, elIntCB = aaLCs[i][:, 4], elLCs[i][:, 4]
+        aaIntCC, elIntCC = aaLCs[i][:, 5], elLCs[i][:, 5]
+
+        # A function to process data in the correct manner and
+        # proper handling of nan's
+        def process_list(int_values, val_values):
+            int_values = np.asarray(int_values, dtype=float)
+            val_values = np.asarray(val_values, dtype=object)
+    
+            # Replace NaNs in int_values with 0
+            int2 = np.where(np.isnan(int_values), 0, int_values)
+    
+            # Replace string "nan" and float NaN in val_values with 0
+            val_cleaned = []
+            for val in val_values:
+                if isinstance(val, str) and val.lower() == "nan":
+                    val_cleaned.append(0)
+                elif isinstance(val, float) and np.isnan(val):
+                    val_cleaned.append(0)
+                else:
+                    val_cleaned.append(val)
+            val2 = np.array(val_cleaned, dtype=object)
+        
+            return int2, val2
+
+        # Correcting equation instances from nan to zero 
+        # for calculations
+        key = Gkeys[i]
+        is_key_1 = key[-1] == "1" and key[-2] != "1"
+        is_key_2 = key[-1] == "2" and key[-2] != "1"
+        is_key_3 = key[-1] == "3" and key[-2] != "1"
+        is_key_4 = key[-1] == "4" and key[-2] != "1"
+        is_key_5 = key[-1] == "5" and key[-2] != "1"
+        is_key_6 = key[-1] == "6" and key[-2] != "1"
+        is_key_7 = key[-1] == "7"
+        is_key_8 = key[-1] == "8"
+        is_key_9 = key[-1] == "9"
+        is_key_10 = key[-1] == "0" and Gkeys[i][-2] == "1"
+        is_key_11 = key[-1] == "1" and key[-2] == "1"
+        is_key_12 = key[-1] == "2" and key[-2] == "1"
+        is_key_13 = key[-1] == "3" and key[-2] == "1"
+        is_key_14 = key[-1] == "4" and key[-2] == "1"
+        is_key_15 = key[-1] == "5" and key[-2] == "1"
+        is_key_16 = key[-1] == "6" and key[-2] == "1"
+                
+        # Atlantic and Arctic data equation processing
+        aaDatao = AAOvalues[i]
+        aaSo, aaTo, aaAo, aaBo, aaCo = aaDatao['S'], aaDatao['T'], aaDatao['A'], aaDatao['B'], aaDatao['C']
+            
+        # Determine which values to use
+        if is_key_1:
+            aaIntCT2, aaIntCA2, aaIntCB2, aaIntCC2 = aaIntCT, aaIntCA, aaIntCB, aaIntCC
+            aaTo2, aaAo2, aaBo2, aaCo2 = aaTo, aaAo, aaBo, aaCo
+        
+        elif is_key_2:
+            aaIntCT2, aaIntCA2, aaIntCC2 = aaIntCT, aaIntCA, aaIntCC
+            aaTo2, aaAo2, aaCo2 = aaTo, aaAo, aaCo  
+        
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+        
+        elif is_key_3:
+            aaIntCT2, aaIntCB2, aaIntCC2 = aaIntCT, aaIntCB, aaIntCC
+            aaTo2, aaBo2, aaCo2 = aaTo, aaBo, aaCo
+        
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+        
+        elif is_key_4:
+            aaIntCT2, aaIntCC2 = aaIntCT, aaIntCC
+            aaTo2, aaCo2 = aaTo, aaCo
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+        
+        elif is_key_5:
+            aaIntCT2, aaIntCA2, aaIntCB2 = aaIntCT, aaIntCA, aaIntCB
+            aaTo2, aaAo2, aaBo2 = aaTo, aaAo, aaBo
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+
+        elif is_key_6:
+            aaIntCT2, aaIntCA2 = aaIntCT, aaIntCA
+            aaTo2, aaAo2 = aaTo, aaAo
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+        
+        elif is_key_7:
+            aaIntCT2, aaIntCB2 = aaIntCT, aaIntCB
+            aaTo2, aaBo2 = aaTo, aaBo
+            
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+            
+        elif is_key_8:
+            aaIntCT2 = aaIntCT
+            aaTo2 = aaTo
+            
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+        
+        elif is_key_9:
+            aaIntCA2, aaIntCB2, aaIntCC2 = aaIntCA, aaIntCB, aaIntCC
+            aaAo2, aaBo2, aaCo2 = aaAo, aaBo, aaCo
+            
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+
+        elif is_key_10:
+            aaIntCA2, aaIntCC2 = aaIntCA, aaIntCC
+            aaAo2, aaCo2 = aaAo, aaCo
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+            
+        elif is_key_11:
+            aaIntCB2, aaIntCC2 = aaIntCB, aaIntCC
+            aaBo2, aaCo2 = aaBo, aaCo
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+        
+        elif is_key_12:
+            aaIntCC2 = aaIntCC
+            aaCo2 = aaCo
+            
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+
+        elif is_key_13:
+            aaIntCA2, aaIntCB2 = aaIntCA, aaIntCB 
+            aaAo2, aaBo2 = aaAo, aaBo
+            
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+            
+        elif is_key_14:
+            aaIntCA2 = aaIntCA
+            aaAo2 = aaAo
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+            
+        elif is_key_15:
+            aaIntCB2 = aaIntCB
+            aaBo2 = aaBo
+        
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+            
+        elif is_key_16:
+            aaIntCT2, aaTo2 = process_list(aaIntCT, aaTo)
+            aaIntCA2, aaAo2 = process_list(aaIntCA, aaAo)
+            aaIntCB2, aaBo2 = process_list(aaIntCB, aaBo)
+            aaIntCC2, aaCo2 = process_list(aaIntCC, aaCo)
+
+        # Convert data lists to NumPy arrays and fix specific value
+        aaAo2 = ['-0.000002' if x == '-2.4319000000000003e-' else x for x in aaAo2]
+        data = [aaIntalpha, aaIntCS, aaIntCT2, aaIntCA2, aaIntCB2, aaIntCC2, aaSo, aaTo2, aaAo2, aaBo2, aaCo2]
+        aaIal, aaICS, aaICT, aaICA, aaICB, aaICC, aaS, aaT, aaA, aaB, aaC = map(lambda x: np.array(x, dtype=float), data)
+        
+        # Compute `aaEst`, the estimate for Atlantic and Arctic
+        aaEst = np.array([a + b*c + d*e + f*g + h*i + j*k
+                          for a, b, c, d, e, f, g, h, i, j, k
+                          in zip(aaIal, aaICS, aaS, aaICT, aaT, aaICA, aaA, aaICB, aaB, aaICC, aaC)])    
+            
+        # Store results
+        aaInterpolants[key] = (aaIal, aaICS, aaICT, aaICA, aaICB, aaICC, aaEst)
+            
+        # Reprocessing "NaN" to 0 as needed for calculations for non-Atlantic and Arctic
+        elDatao = ElseOvalues[i]
+        elSo, elTo, elAo, elBo, elCo = elDatao['S'], elDatao['T'], elDatao['A'], elDatao['B'], elDatao['C']
+            
+        # Determine which values to use
+        if is_key_1:
+            elIntCT2, elIntCA2, elIntCB2, elIntCC2 = elIntCT, elIntCA, elIntCB, elIntCC
+            elTo2, elAo2, elBo2, elCo2 = elTo, elAo, elBo, elCo
+            
+        elif is_key_2:
+            elIntCT2, elIntCA2, elIntCC2 = elIntCT, elIntCA, elIntCC
+            elTo2, elAo2, elCo2 = elTo, elAo, elCo
+        
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+        
+        elif is_key_3:
+            elIntCT2, elIntCB2, elIntCC2 = elIntCT, elIntCB, elIntCC
+            elTo2, elBo2, elCo2 = elTo, elBo, elCo
+        
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+                          
+        elif is_key_4:
+            elIntCT2, elIntCC2 = elIntCT, elIntCC
+            elTo2, elCo2 = elTo, elCo
+            
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+        
+        elif is_key_5:
+            elIntCT2, elIntCA2, elIntCB2 = elIntCT, elIntCA, elIntCB
+            elTo2, elAo2, elBo2 = elTo, elAo, elBo
+            
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+            
+        elif is_key_6:
+            elIntCT2, elIntCA2 = elIntCT, elIntCA
+            elTo2, elAo2 = elTo, elAo
+        
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+        
+        elif is_key_7:
+            elIntCT2, elIntCB2 = elIntCT, elIntCB 
+            elTo2, elBo2 = elTo, elBo
+            
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+            
+        elif is_key_8:
+            elIntCT2 = elIntCT
+            elTo2 = elTo
+            
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+            
+        elif is_key_9:
+            elIntCA2, elIntCB2, elIntCC2 = elIntCA, elIntCB, elIntCC
+            elAo2, elBo2, elCo2 = elAo, elBo, elCo
+        
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            
+        elif is_key_10:
+            elIntCA2, elIntCC2 = elIntCA, elIntCC
+            elAo2, elCo2 = elAo, elCo
+        
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+            
+        elif is_key_11:
+            elIntCB2, elIntCC2 = elIntCB, elIntCC
+            elBo2, elCo2 = elBo, elCo
+            
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            
+        elif is_key_12:
+            elIntCC2 = elIntCC
+            elCo2 = elCo
+            
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+            
+        elif is_key_13:
+            elIntCA2, elIntCB2 = elIntCA, elIntCB
+            elAo2, elBo2 = elAo, elBo
+        
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+        
+        elif is_key_14:
+            elIntCA2 = elIntCA
+            elAo2 = elAo
+        
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+            
+        elif is_key_15:
+            elIntCB2 = elIntCB
+            elBo2 = elBo
+            
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+            
+        elif is_key_16:
+            
+            elIntCT2, elTo2 = process_list(elIntCT, elTo)
+            elIntCA2, elAo2 = process_list(elIntCA, elAo)
+            elIntCB2, elBo2 = process_list(elIntCB, elBo)
+            elIntCC2, elCo2 = process_list(elIntCC, elCo)
+
+        # Convert all input lists to NumPy arrays in one go
+        data2 = [elIntalpha, elIntCS, elIntCT2, elIntCA2, elIntCB2, elIntCC2, elSo, elTo2, elAo2, elBo2, elCo2]
+        elIal, elICS, elICT, elICA, elICB, elICC, elS, elT, elA, elB, elC = map(lambda x: np.array(x, dtype=float), data2)
+            
+        # compute 'elEst', the estimate for not Alantic or Atctic
+        elEst = np.array([a + b*c + d*e + f*g + h*i + j*k
+                          for a, b, c, d, e, f, g, h, i, j, k
+                          in zip(elIal, elICS, elS, elICT, elT, elICA, elA, elICB, elB, elICC, elC)])
+        # Store the results
+        elInterpolants[key] = (elIal, elICS, elICT, elICA, elICB, elICC, elEst)
+
+    Estimate, CoefficientsUsed = {}, {}
+    for kcombo in AAdata.keys():
+        AAdata[kcombo]["C0"] = aaInterpolants[kcombo][0]
+        AAdata[kcombo]["CS"] = aaInterpolants[kcombo][1] 
+        AAdata[kcombo]["CT"] = aaInterpolants[kcombo][2] 
+        AAdata[kcombo]["CA"] = aaInterpolants[kcombo][3] 
+        AAdata[kcombo]["CB"] = aaInterpolants[kcombo][4]
+        AAdata[kcombo]["CC"] = aaInterpolants[kcombo][5]
+        AAdata[kcombo]["Estimate"] = aaInterpolants[kcombo][6]
+    for kcombo in Elsedata.keys():
+        Elsedata[kcombo]["C0"] = elInterpolants[kcombo][0]
+        Elsedata[kcombo]["CS"] = elInterpolants[kcombo][1]
+        Elsedata[kcombo]["CT"] = elInterpolants[kcombo][2]
+        Elsedata[kcombo]["CA"] = elInterpolants[kcombo][3]
+        Elsedata[kcombo]["CB"] = elInterpolants[kcombo][4] 
+        Elsedata[kcombo]["CC"] = elInterpolants[kcombo][5]
+        Elsedata[kcombo]["Estimate"] = elInterpolants[kcombo][6]
+            
+        # Merge AA and Else data by key
+        merged = {}
+        for key in AAdata[kcombo].keys():
+            merged[key] = np.concatenate([AAdata[kcombo][key], Elsedata[kcombo][key]])
+        
+        # Get sort order based on "Order"
+        sort_index = np.argsort(merged["Order"])
+    
+        # Sort each field in the merged dictionary
+        TotData = {key: val[sort_index] for key, val in merged.items()}
+        
+        # Store estimate values as dictionary with 1 key 
+        Estimate[kcombo] =  TotData["Estimate"]
+
+        # Store coefficients as dictionary with named keys
+        CoefficientsUsed[kcombo] = {
+            "Intercept": TotData["C0"],
+            "Coef S": TotData["CS"],
+            "Coef T": TotData["CT"],
+            "Coef A": TotData["CA"],
+            "Coef B": TotData["CB"],
+            "Coef C": TotData["CC"]
+        }
+        
+    return Estimate, CoefficientsUsed