PyESPER 1.0.0__py3-none-any.whl

PyESPER/__init__.py

@@ -0,0 +1,28 @@
+from .final_formatting import final_formatting
+from .organize_nn_output import organize_nn_output
+from .adjust_pH_DIC import adjust_pH_DIC
+from .input_AAinds import input_AAinds	
+from .pH_adjcalc import pH_adjcalc
+from .coefs_AAinds import coefs_AAinds
+from .inputdata_organize import inputdata_organize	
+from .pH_adjustment import pH_adjustment
+from .defaults import defaults
+from .interpolate import interpolate
+from .pH_DIC_nn_adjustment import pH_DIC_nn_adjustment
+from .define_polygons import define_polygons
+from .iterations import iterations
+from .process_netresults import process_netresults
+from .emlr_estimate import emlr_estimate
+from .lir_uncertainties import process_uncertainties
+from .lir_uncertainties import measurement_uncertainty_defaults	
+from .run_nets import run_nets
+from .emlr_nn import emlr_nn			
+from .simplecantestimatelr import simplecantestimatelr
+from .errors import errors
+from .temperature_define import temperature_define
+from .fetch_data import fetch_data
+from .fetch_polys_NN import fetch_polys_NN	
+from .organize_data import organize_data
+from .lir import lir
+from .nn import nn
+from .mixed import mixed

PyESPER/adjust_pH_DIC.py

@@ -0,0 +1,73 @@
+def adjust_pH_DIC(DesiredVariables, VerboseTF, Dates, Est_pre={}, PredictorMeasurements={}, OutputCoordinates={}, **kwargs):
+
+    """
+    If present, adjusting pH and DIC for anthropogenic carbon (Cant) within LIRs. Cant adjustment methods
+        are based on those from ESPERv1, which is a TTD-based assumption/simplification but does not
+        use the Tracer-based Rapid Anthropogenic Carbon Estimation data product, TRACE. Rather,
+        interpolation from a gridded product is used to produce estimates for the year 2002 and data is
+        adjusted to/from this reference year. This is the first of three steps for Cant adjustment
+
+    Inputs:
+        DesiredVariables: List of desired variables to estimate
+        VerboseTF: Boolean indicating whether the user wants suppression of warnings
+        Dates: List of dates for estimates
+        Est_pre: Dictionary of preliminary estimates for each variable-equation case scenario
+        PredictorMeasurements: Dictionary of input measurements for each variable-equation case scenario
+        OutputCoordinates: Dictionary of coordinates for locations of estimates
+        **kwargs: Please see README for full informations
+
+    Outputs:
+        Cant_adjusted: Dictionary of values adjusted for anthropogenic carbon for each combination
+        Cant: Numpy array of estimates for anthropogenic carbon for each estimate
+        Cant2002: Numpy array of estimates for anthropogenic carbon in the year 2002 for each estimate
+    """
+
+    import numpy as np
+    from PyESPER.simplecantestimatelr import simplecantestimatelr
+
+    # Predefining output dictionary and formatting estimates
+    Cant_adjusted={}
+    combos2 = list(Est_pre.keys())
+    values2 = []
+    for c, v in Est_pre.items():
+        vals = np.array([v])
+        vals = vals.flatten()
+        values2.append(vals)
+    values2 = np.array(values2)
+
+    # Predefining anthropogenic carbon numpy arrays
+    n = len(Dates)
+    Cant, Cant2002 = np.zeros(n), np.zeros(n)
+
+    # Only proceed if adjustment is needed
+    if "EstDates" in kwargs and ("DIC" in DesiredVariables or "pH" in DesiredVariables):
+        if VerboseTF:
+            print("Estimating anthropogenic carbon for PyESPER_LIR.")
+
+        # Normalize longitude to [0, 360]
+        longitude = np.mod(np.array(OutputCoordinates["longitude"]), 360)
+        latitude = np.array(OutputCoordinates["latitude"])
+        depth = np.array(OutputCoordinates["depth"])
+    
+        # Estimate anthropogenic carbon (Cant) and anthropogenic carbon for the year 2002 (Cant2002)
+        Cant, Cant2002 = simplecantestimatelr(Dates, longitude, latitude, depth)
+        Cant, Cant2002 = np.array(Cant), np.array(Cant2002)
+    
+        for combo in range(0, len(combos2)):
+            comb = combos2[combo]
+            val = values2[combo]
+            est1 = []
+        
+            # Only adjust if combo is DIC
+            if "dic" in comb.lower():
+                adjusted = np.where(val == "nan", np.nan, val + Cant - Cant2002)
+                est1.append(adjusted)
+    
+            if "dic" not in comb.lower():
+                nanfix = np.where(val == "nan", np.nan, val)
+                est1.append(nanfix)
+        
+            Cant_adjusted[combos2[combo]] = est1
+
+    return Cant_adjusted, Cant, Cant2002 
+

PyESPER/coefs_AAinds.py

@@ -0,0 +1,53 @@
+def coefs_AAinds(Equations, LIR_data):
+
+    """
+    Separates coefficients from MATLAB ESPERv1 into Atlantic and Arctic or other regions.
+
+    Inputs:
+        Equations: List of equations for use in ESPERs
+        LIR_data: List of dictionaries of data from MATLAB trainings (pre-processed)
+
+    Outputs:
+        Gdf: Dictionary of pre-trained and processed LIR data for grid of coordinates
+        CsDesired: Dictionary of equation coefficients based on user-defined output
+    """
+
+    import numpy as np
+
+    # Use boolean for AA or Else to separate coefficients into Atlantic or not
+    GridCoords, Cs, AAInds = LIR_data[:3]
+    DVs, CsVs = list(Cs.keys()), list(Cs.values())
+    ListVars = np.arange(len(AAInds))
+    GridValues = np.array(list(GridCoords.values())[0], dtype=float)
+    AAIndValues = np.array(list(AAInds.values())[0], dtype=float)
+
+    lon_grid, lat_grid, d2d_grid, aainds = np.array((GridValues[:,0])), np.array((GridValues[:,1])), \
+       np.array(GridValues[:,2])/25, np.array(AAIndValues[:,0])
+
+    names = ['lon', 'lat', 'd2d', "C_alpha", "C_S", "C_T", "C_A", "C_B", "C_C", 'AAInds']
+    Gdf, CsDesired = {}, {}
+
+    # Moving data into pre-defined dictionaries
+    for lvar, name in zip(ListVars, DVs):
+        Cs2 = CsVs[:][lvar][:]
+        for e in Equations:
+            CsName = f'Cs{name}{e}'
+            CsDesired[CsName] = Cs2[e-1][:]
+            Cs3 = Cs2[e-1][:]
+            C_alpha, C_S, C_T, C_A, C_B, C_C = np.array(Cs3[:,0]), np.array(Cs3[:,1]), np.array(Cs3[:,2]), np.array(Cs3[:,3]), \
+                np.array(Cs3[:,4]), np.array(Cs3[:,5])
+            Gdf[f"{name}{e}"] = {
+                names[0]: np.array(lon_grid),
+                names[1]: np.array(lat_grid),
+                names[2]: np.array(d2d_grid),
+                names[3]: np.array(C_alpha),
+                names[4]: np.array(C_S),
+                names[5]: np.array(C_T),
+                names[6]: np.array(C_A),
+                names[7]: np.array(C_B),
+                names[8]: np.array(C_C),
+                names[9]: np.array(aainds)
+            }
+
+    return Gdf, CsDesired
+

PyESPER/defaults.py

@@ -0,0 +1,71 @@
+def defaults (DesiredVariables, PredictorMeasurements={}, OutputCoordinates={}, **kwargs):
+
+    """
+    Set default values and bookkeep inputs.
+
+    Inputs: 
+        DesiredVariables: List of desired output variables (user-requested)
+        PredictorMeasurements: Dictionary of user-provided predictor mesasurements (salinity, etc.)
+        OutputCoordinates: Dictionary of user-provided coordinates
+        **kwargs: Please see README for more information
+
+    Outputs:
+        Equations: numpy array of equations (either user-defined or default)
+        n: Scalar representing number of required estimates for each variable-equation comination
+        e: Scalar representing number of requested equations
+        p: Scalar representing number of requested output variables
+        VerboseTF: Boolean read-in of whether user wants to suppress optional warnings
+        C: Dictionary of processed geographic coordinates
+        PerKgSwTF: Boolean representing whether user input is in molal or molar units
+        MeasUncerts: Dictionary of user input measurement uncertainty values or empty 
+            dictionary if not provided   
+    """
+
+    import numpy as np
+
+    # Check and define Equations based on user-defined kwargs, or use default values
+    Equations = kwargs.get("Equations", list(range(1, 17)))
+    
+    # Reading dimensions of user input
+    n = max(len(v) for v in OutputCoordinates.values()) 
+                
+    # Checking kwargs for presence of VerboseTF and EstDates, and Equations, and defining defaults, as needed
+    VerboseTF = kwargs.get("VerboseTF", True)
+        
+    # Set EstDates based on kwargs, defaulting to 2002.0 if not provided
+    if "EstDates" in kwargs:
+        d = np.array(kwargs["EstDates"])
+        if len(d) != n:
+            EstDates = np.tile(d, (n + 1, 1)).reshape(-1)
+        else:
+            EstDates = d
+    else:
+        EstDates = np.full(n, 2002.0)
+        
+    # Bookkeeping coordinates
+    C = {}
+    longitude = np.array(OutputCoordinates["longitude"])
+    longitude[longitude > 360] = np.remainder(longitude[longitude > 360], 360)
+    longitude[longitude < 0] = longitude[longitude<0] + 360
+    C["longitude"] = longitude
+    C["latitude"] = OutputCoordinates["latitude"]
+    C["depth"] = OutputCoordinates["depth"]   
+    
+    # Defining or reading in PerKgSwTF
+    PerKgSwTF = kwargs.get("PerKgSwTF", True)
+
+    # Defining Measurement Uncertainties
+    MeasUncerts = kwargs.get("MeasUncerts", {})
+
+    # Validate MeasUncerts dimensions
+    if MeasUncerts:
+        if max(len(v) for v in MeasUncerts.values()) != n:
+            if min(len(v) for v in MeasUncerts.values()) != 1:
+                raise CustomError(
+                    "MeasUncerts must be undefined, a vector with the same number of elements as "
+                    "PredictorMeasurements has columns, or a matrix of identical dimension to PredictorMeasurements."
+                )
+        if len(MeasUncerts) != len(PredictorMeasurements):
+            print("Warning: Different numbers of input uncertainties and input measurements.")
+
+    return Equations, n, VerboseTF, EstDates, C, PerKgSwTF, MeasUncerts

PyESPER/define_polygons.py

@@ -0,0 +1,68 @@
+def define_polygons(C={}):
+
+    """
+    Defining and structuring indexing within ocean region polygons.
+    First defines the polygons, then assesses the location of user-provided
+    coordinates within polygons.
+
+    Inputs:
+        C: Dictionary of adjusted coordinates
+
+    Output:
+        df: Dictionary of adjusted coordinates with boolean indicators for specific
+            ocean regions
+    """
+
+    import numpy as np
+    import matplotlib.path as mpltPath
+
+    # Define polygons for Atlantic and Arctic (AA) or other (Else) ocean basins
+    LNAPoly = np.array([[300, 0], [260, 20], [240, 67], [260, 40], [361, 40], [361, 0], [298, 0]])
+    LSAPoly = np.array([[298, 0], [292, -40.01], [361, -40.01], [361, 0], [298, 0]])
+    LNAPolyExtra = np.array([[-1, 50], [40, 50], [40, 0], [-1, 0], [-1, 50]])
+    LSAPolyExtra = np.array([[-1, 0], [20, 0], [20, -40], [-1, -40], [-1, 0]])
+    LNOPoly = np.array([[361, 40], [361, 91], [-1, 91], [-1, 50], [40, 50], [40, 40], [104, 40], [104, 67], [240, 67],
+                    [280, 40], [361, 40]])
+    xtra = np.array([[0.5, -39.9], [.99, -39.9], [0.99, -40.001], [0.5, -40.001]])
+    polygons = [LNAPoly, LSAPoly, LNAPolyExtra, LSAPolyExtra, LNOPoly, xtra]
+
+    # Create Paths
+    paths = [mpltPath.Path(poly) for poly in polygons]
+
+    # Extract coordinates
+    longitude, latitude, depth = np.array(C["longitude"]), np.array(C["latitude"]), np.array(C["depth"])
+
+    # Check if coordinates are within each polygon
+    conditions = [path.contains_points(np.column_stack((longitude, latitude))) for path in paths]
+
+    # Combine conditions
+    AAIndsM = np.logical_or.reduce(conditions)
+
+    # Adding Bering Sea, S. Atl., and S. African Polygons separately
+    Bering = np.array([[173, 70], [210, 70], [210, 62.5], [173, 62.5], [173, 70]])
+    beringpath = mpltPath.Path(Bering)
+    beringconditions = beringpath.contains_points(np.column_stack((longitude, latitude)))
+    SAtlInds, SoAfrInds = [], []
+    for i, z in zip(longitude, latitude):
+        # Check if the conditions are met for Southern Atlantic
+        if (-34 > z > -44):  # Check latitude first to reduce unnecessary checks
+            if i > 290 or i < 20:
+                SAtlInds.append('True')   
+            else:
+                SAtlInds.append('False')
+
+            # Check if the condition is met for Southern Africa
+            if 19 < i < 27:
+                SoAfrInds.append('True')
+            else:
+                SoAfrInds.append('False')
+        else:
+            SAtlInds.append('False')
+            SoAfrInds.append('False')
+
+    # Create Dictionary with boolean indicators
+    df = {'AAInds': AAIndsM, 'BeringInds': beringconditions, 'SAtlInds': SAtlInds, \
+        'SoAfrInds': SoAfrInds, 'Lat': latitude, 'Lon': longitude, 'Depth': depth}
+    
+    return df
+

PyESPER/emlr_estimate.py

@@ -0,0 +1,156 @@
+def emlr_estimate(Equations, DesiredVariables, Path, OutputCoordinates={}, PredictorMeasurements={}, UDict={}, DUDict={}, Coefficients={}, **kwargs):
+    
+    """
+    Uncertainty estimation step 1 for LIRs
+
+    Inputs:
+        Equations: List of equations
+        DesiredVariables: List of variables to estimate
+        Path: User-defined computer path
+        OutputCoordinates: Dictionary of locations where estimates are requested
+        PredictorMeasurements: Dictionary of measurements provided by user
+        UDict: Dictionary of user-defined measurement uncertainties
+        DUDict: Dictionary of default measurement uncertainties
+        Coefficients: Dictionary of dictionaries of coefficients for each
+            variable-equation scenario
+        **kwargs: Please see README for full description
+
+    Output:
+        EMLR: Dictionary of uncertainty values for each desired variable-equation
+            case scenario and estimate
+    """
+
+    import numpy as np
+    from scipy.interpolate import griddata
+    from PyESPER.fetch_data import fetch_data
+
+    # Predefine dictionary and lists to fill
+    EMLR, varnames, EqM = {}, [], []
+
+    # Iterating over variables to fetch data this time
+    for dv in DesiredVariables:
+        # Fetch LIR data and process into grid arrays
+        LIR_data = fetch_data([dv], Path)
+
+        # Construct the grid array
+        LIR_data = fetch_data([dv], Path)
+
+        # Some formatting of the uncertainties from the import
+        arr = np.array(LIR_data)
+        arr = arr[3]
+        arritem = arr.item()
+
+        UGridArray = np.array([
+            np.nan_to_num([arritem[i][c][b][a] for a in range(16) for b in range(11) for c in range(8)])
+            for i in range(len(arritem))
+        ]).T
+
+        # Grid columns: UDepth, USal, Eqn, RMSE
+        UDepth, USal, Eqn, RMSE = UGridArray.T
+        UGridPoints = (UDepth, USal, Eqn)
+        UGridValues = RMSE
+    
+        # Iterating over equations within variables to interpolate the uncertainties to
+        # desired locations
+        for eq in Equations:
+            varname = dv + str(eq)
+            varnames.append(varname)
+            EM = []
+
+            eq_repeated = np.full_like(OutputCoordinates['depth'], eq)
+            UGridPointsOut = (
+                np.array(OutputCoordinates['depth']),
+                np.array(PredictorMeasurements['salinity']),  
+                eq_repeated
+            )
+            emlr = griddata(UGridPoints, UGridValues, UGridPointsOut, method='linear')
+
+            combo = f"{dv}{eq}"
+            Coefs = {
+                k: np.nan_to_num(np.array(UDict[combo][k]))
+                for k in ["US", "UT", "UA", "UB", "UC"]
+            }
+        
+            uncdfs, duncdfs = UDict[combo], DUDict[combo]
+        
+            # Extract keys
+            keys = list(uncdfs.keys())
+        
+            # Function to fill arrays with floats
+            def safe_fill(arr, fill_val):
+                arr = np.array(arr, dtype=float)
+                arr[np.isnan(arr)] = fill_val
+                return arr
+
+            # Fill=-9999 if needed
+            USu2 = [safe_fill(uncdfs[k], -9999.0) for k in keys]
+            UTu2 = [safe_fill(uncdfs[k], -9999.0) for k in keys]
+            UAu2 = [safe_fill(uncdfs[k], -9999.0) for k in keys]
+            UBu2 = [safe_fill(uncdfs[k], -9999.0) for k in keys]
+            UCu2 = [safe_fill(uncdfs[k], -9999.0) for k in keys]
+            
+            DUSu2 = [safe_fill(duncdfs[k], -9999.0) for k in keys]
+            DUTu2 = [safe_fill(duncdfs[k], -9999.0) for k in keys]
+            DUAu2 = [safe_fill(duncdfs[k], -9999.0) for k in keys]
+            DUBu2 = [safe_fill(duncdfs[k], -9999.0) for k in keys]
+            DUCu2 = [safe_fill(duncdfs[k], -9999.0) for k in keys]
+
+           # Compute uncertainty estimates
+            for eq in Equations:
+                EM = []
+            
+                for cucombo in range(len(Coefs["US"])):
+                    # Grab each coefficient
+                    s = Coefs["US"][cucombo]
+                    t = Coefs["UT"][cucombo]
+                    a = Coefs["UA"][cucombo]
+                    b = Coefs["UB"][cucombo] 
+                    c = Coefs["UC"][cucombo]
+
+                    # Main uncertainty components
+                    s1 = (s * USu2[0][cucombo]) ** 2
+                    t1 = (t * UTu2[1][cucombo]) ** 2
+                    a1 = (a * UAu2[2][cucombo]) ** 2
+                    b1 = (b * UBu2[3][cucombo]) ** 2
+                    c1 = (c * UCu2[4][cucombo]) ** 2
+                    sum2 = s1 + t1 + a1 + b1 + c1
+            
+                    # Delta uncertainties
+                    ds1 = (s * DUSu2[0][cucombo]) ** 2
+                    dt1 = (t * DUTu2[1][cucombo]) ** 2
+                    da1 = (a * DUAu2[2][cucombo]) ** 2
+                    db1 = (b * DUBu2[3][cucombo]) ** 2
+                    dc1 = (c * DUCu2[4][cucombo]) ** 2
+                    dsum2 = ds1 + dt1 + da1 + db1 + dc1
+
+                   # Final uncertainty
+                    uncestimate = np.sqrt(sum2 - dsum2 + emlr[cucombo] ** 2)
+                    EM.append(uncestimate) 
+                    
+                EqM.append(EM)
+                    
+            # Post-process and apply nan masks
+            EqM2 = []
+            for EM_arr in EqM:
+                UncertEst = np.array(EM_arr, dtype=float)
+                    
+                # Convert -9999 markers to np.nan based on rules
+                UncertEst[USu2[0] == -9999] = np.nan
+                    
+                if eq in [1, 2, 3, 4, 5, 6, 7, 8]:  
+                    UncertEst[UTu2[1] == -9999] = np.nan
+                if eq in [1, 2, 5, 6, 9, 10, 13, 14]:
+                    UncertEst[UAu2[2] == -9999] = np.nan
+                if eq in [1, 3, 5, 7, 9, 11, 13, 15]: 
+                    UncertEst[UBu2[3] == -9999] = np.nan
+                if eq in [1, 2, 3, 4, 9, 10, 11, 12]: 
+                    UncertEst[UCu2[4] == -9999] = np.nan
+
+                EqM2.append(UncertEst)
+                
+            # Final assembly into dictionary
+            for i, key in enumerate(varnames):
+                EMLR[key] = EqM2[i]
+                    
+    return EMLR
+

PyESPER/emlr_nn.py

@@ -0,0 +1,54 @@
+def emlr_nn(Path, DesiredVariables, Equations, OutputCoordinates={}, PredictorMeasurements={}, **kwargs):
+
+    """
+    Estimating EMLR for neural networks.
+    Returns a dictionary with (DesiredVariable, Equation) as keys and Uncertainties as values.
+    """
+
+    from PyESPER.fetch_polys_NN import fetch_polys_NN
+    import numpy as np
+    from scipy.interpolate import griddata
+
+    EMLR = {}
+
+    for dv in DesiredVariables:
+        DV = f"{dv}"
+        NN_data = fetch_polys_NN(Path, [DV])
+
+        data_arrays = [
+            np.nan_to_num(np.array([
+                NN_data[1][i][c][b][a]
+                for a in range(16)
+                for b in range(11)
+                for c in range(8)
+            ]))
+            for i in range(4)
+        ]
+
+        # Create Dictionary of predetermined Uncertainties
+        UGridArray = {
+            'UDepth': data_arrays[0],
+            'USal': data_arrays[1],
+            'Eqn': data_arrays[2],
+            'RMSE': data_arrays[3],
+        }
+
+        UGridPoints = (UGridArray['UDepth'], UGridArray['USal'], UGridArray['Eqn'])
+        UGridValues = UGridArray['RMSE']
+
+        for eq in Equations:
+            name = dv + str(eq)
+            eq_array = np.full_like(OutputCoordinates['depth'], eq, dtype=float)
+
+            # Perform estimation for each equation
+            EM = griddata(
+                UGridPoints,
+                UGridValues,
+                (OutputCoordinates['depth'], PredictorMeasurements['salinity'], eq_array),
+                method='linear'
+            )
+
+            EMLR[name] = EM
+
+    return EMLR
+

PyESPER/errors.py

@@ -0,0 +1,39 @@
+def errors(OutputCoordinates={}, PredictorMeasurements={}):
+
+    """
+    Custom error messages for PyESPER that check inputs and ensure that formatting and other requirements are met
+    """
+
+    # Checking for presence of required input parameters and raising a custom error message if needed
+    class CustomError(Exception):
+        pass
+
+    required_coords = ("longitude", "latitude", "depth")
+    for coord_name in required_coords:
+        if coord_name not in OutputCoordinates:
+            raise CustomError(f"Warning: Missing {coord_name} in OutputCoordinates.")
+
+    if "salinity" not in PredictorMeasurements: 
+        raise CustomError("Warning: Missing salinity measurements. Salinity is a required input.")
+            
+    if "oxygen" in PredictorMeasurements and "temperature" not in PredictorMeasurements:
+        raise CustomError("Warning: Missing temperature measurements. Temperature is required when oxygen is provided.")
+
+    # Check temperature sanity and print a warning for out-of-range values
+    if "temperature" in PredictorMeasurements and any(t < -5 or t > 50 for t in PredictorMeasurements["temperature"]):
+        print("Warning: Temperatures below -5°C or above 50°C found. PyESPER is not designed for seawater with these properties. Ensure temperatures are in Celsius.")
+                
+    if any(s < 5 or s > 50 for s in PredictorMeasurements["salinity"]):
+        print("Warning: Salinities less than 5 or greater than 50 have been found. ESPER is not intended for seawater with these properties.")
+        
+    if any(d < 0 for d in OutputCoordinates["depth"]):
+        print("Warning: Depth can not be negative.")
+        
+    if any(l > 90 for l in OutputCoordinates["latitude"]):
+        print("Warning: A latitude >90 deg (N or S) has been detected. Verify latitude is entered correctly as an input.")
+    
+    # Checking for commonly used missing data indicator flags. Consider adding your commonly used flags here.  
+    if any(l == -9999 or l == -9 or l == -1e20 for l in OutputCoordinates["latitude"]):
+           print("Warning: A common non-NaN missing data indicator (e.g., -999, -9, -1e20) was detected in the input measurements provided. Missing data should be replaced with NaNs. Otherwise, ESPER will interpret your inputs at face value and give terrible estimates.")  
+ 
+    print("Please note that, for consistency with MATLAB ESPERv1, the now-deprecated sw package is used. This will be replaced with gsw in future updates.")

PyESPER/fetch_data.py

@@ -0,0 +1,54 @@
+def fetch_data (DesiredVariables, Path):
+    
+    """
+    Gathers the necessary LIR files that were pre-trained in MATLAB ESPERs
+
+    Inputs:
+        DesiredVariables: List of desired output estimate variables
+        Path: User-defined computer path of locations of files
+
+    Outputs:
+        LIR_data: List of dictionaries of LIR data
+    """
+
+    from scipy.io import loadmat
+    import os
+    import numpy as np
+
+    # Predefine dictionaries of output
+    AAIndsCs, GridCoords, Cs = {}, {}, {}
+
+    # Load necessary files
+    for v in DesiredVariables:
+        fname1 = os.path.join(Path, f"Mat_fullgrid/LIR_files_{v}_fullCs1.mat")
+        fname2 = os.path.join(Path, f"Mat_fullgrid/LIR_files_{v}_fullCs2.mat")
+        fname3 = os.path.join(Path, f"Mat_fullgrid/LIR_files_{v}_fullCs3.mat")
+        fname4 = os.path.join(Path, f"Mat_fullgrid/LIR_files_{v}_fullGrids.mat")
+
+        Cs1 = loadmat(fname1)
+        Cs2 = loadmat(fname2)
+        Cs3 = loadmat(fname3)
+        Grid = loadmat(fname4)
+
+        # Extract and store all arrays
+        UncGrid = np.array(Grid["UncGrid"][0][0])
+        GridCoodata = np.array(Grid["GridCoords"])
+        AAInds = np.array(Grid["AAIndsM"])
+
+        Csdata1 = np.array(Cs1["Cs1"])
+        Csdata2 = np.array(Cs2["Cs2"])
+        Csdata3 = np.array(Cs3["Cs3"])
+
+        # Store as NumPy arrays
+        AAIndsCs[v] = AAInds
+        GridCoords[v] = GridCoodata
+
+        # Combine along axis 1, then store each layer in list
+        Csdata = np.concatenate((Csdata1, Csdata2, Csdata3), axis=1)
+        Cs[v] = [Csdata[:, :, i] for i in range(Csdata.shape[2])]
+
+    # Store all in one list
+    LIR_data = [GridCoords, Cs, AAIndsCs, UncGrid]
+
+    return LIR_data
+

PyESPER/fetch_polys_NN.py

@@ -0,0 +1,16 @@
+def fetch_polys_NN(Path, DesiredVariables):
+
+    """
+    Loads the uncertainty polygons for NNs
+    """
+
+    from scipy.io import loadmat
+    import os
+
+    for v in DesiredVariables:
+        fname = os.path.join(Path, f"Uncertainty_Polys/NN_files_{v}_Unc_Poly.mat")
+        NNs = loadmat(fname)
+        Polys, UncGrid = NNs["Polys"][0][0], NNs["UncGrid"][0][0]
+
+    NN_data = [Polys, UncGrid]
+    return NN_data

PyESPER/final_formatting.py

@@ -0,0 +1,25 @@
+def final_formatting(DesiredVariables, Cant_adjusted={}, Est_pre={}):
+
+    """
+    Formatting the final data output for estimates
+
+    Inputs:
+        DesiredVariables: List of desired variables to estimate
+        Cant_adjusted: Dictionary of estimates adjusted for anthropogenic
+            carbon for each combination
+        Est_pre: Dictionary of estimates for each combination
+
+    Output:
+        Estimates: Dictionary of estimates for each combination
+    """
+
+    # Conditional to whether anthropogenic carbon was needed or not
+    if ("pH" or "DIC") in DesiredVariables:
+        Estimates=Cant_adjusted
+        print("anthropogenic carbon has been incorporated into some estimates")
+    else:
+        Estimates=Est_pre
+        print("anthropogenic carbon is not considered for these estimates")
+
+    return Estimates
+