PyESPER 1.0.1__tar.gz

pyesper-1.0.1/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: PyESPER
+Version: 1.0.1
+Summary: Python version of ESPERv1
+Author: LMD
+Author-email: lmdias@uw.edu
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: seawater
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: PyCO2SYS
+Requires-Dist: pandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: summary
+
+# PyESPER
+version 1.0.0
+
+<ins>Note:</ins>
+This is for use of the [PyESPER](https://github.com/LarissaMDias/PyESPER/blob/main) package. This package is being developed in parallel with [pyTRACE](https://github.com/d-sandborn/pyTRACE/tree/main).
+
+## Quick Start
+Please see the associated [Examples](https://github.com/LarissaMDias/PyESPER/blob/main/examples.py) for a quick example of use of the preliminary PyESPER. To run this code, you will need to first make sure that you have downloaded the required associated files from the GitHub page as follows. You will also need to ensure that the installed package [requirements](https://github.com/LarissaMDias/PyESPER/blob/main/requirements.txt) are met. The example uses the [GLODAPv2.2023](https://glodap.info) dataset and requires the [glodap](https://github.com/BjerknesClimateDataCentre/glodap/tree/master) package be installed.
+
+To install PyESPER to your remote depository, simply run the following in your terminal: 
+
+pip install git+https://github.com/LarissaMDias/PyESPER
+
+Mat_fullgrid folder: 
+Folder of .mat files needed for each variable to be estimated, necessary for PyESPER_LIR or PyESPER_Mixed
+    
+NeuralNetworks folder:
+Folder of .py files needed for each variable to be estimated, necessary for running PyESPER_NN or PyESPER_Mixed. These currently must be unpacked into the main directory. 
+    
+Uncertainty_Polys folder:
+Folder of .mat files needed for ach variable to be estimated, necessary for running PyESPER_NN or PyESPER_Mixed
+    
+SimpleCantEstimateLR.csv:
+File necessary for estimating anthropogenic carbon component for pH or DIC
+    
+## Introduction
+PyESPER is a Python implementation of MATLAB Empirical Seawater Property Estimation Routines ([ESPERs](https://github.com/BRCScienceProducts/ESPER)), and the present version consists of a preliminary package which implements these routines. These routines provide estimates of seawater biogeochemical properties at user-provided sets of coordinates, depth, and available biogeochemical properties. Three algorithm options are available through these routines: 
+
+1. Locally interpolated regressions (LIRs)
+2. Neural networks (NNs)
+3. Mixed
+
+The routines predict coefficient and intercept values for a set of up to 16 equations, as follows:
+(S=salinity, T=temperature, oxygen=dissolved oxygen molecule... see "PredictorMeasurements" for units). 
+1.    S, T, A, B, C
+2.    S, T, A, C
+3.    S, T, B, C
+4.    S, T, C
+5.    S, T, A, B
+6.    S, T, A
+7.    S, T, B
+8.    S, T
+9.    S, A, B, C
+10.   S, A, C
+11.   S, B, C
+12.   S, C
+13.   S, A, B
+14.   S, A
+15.   S, B
+16.   S
+
+<ins>DesiredVariable: A, B, C</ins>
+
+-TA: nitrate, oxygen, silicate
+
+-DIC: nitrate, oxygen, silicate
+
+-pH: nitrate, oxygen, silicate
+
+-phosphate: nitrate, oxygen, silicate
+
+-nitrate: phosphate, oxygen, silicate
+
+-silicate: phosphate, oxygen, nitrate
+
+-oxygen: phosphate, nitrate, silicate
+
+### Documentation and citations:
+LIARv1: Carter et al., 2016, doi: 10.1002/lom3.10087
+
+LIARv2, LIPHR, LINR citation: Carter et al., 2018, doi: 10.1002/lom3.10232
+
+LIPR, LISIR, LIOR, first described/used: Carter et al., 2021, doi: 10.1002/lom3/10232
+
+LIRv3 and ESPER_NN (ESPERv1.1): Carter, 2021, doi: 10.5281/ZENODO.5512697
+
+PyESPER is a Python implementation is ESPER:
+Carter et al., 2021, doi: 10.1002/lom3/10461
+
+ESPER_NN is inspired by CANYON-B, which also uses neural networks:
+Bittig et al., 2018, doi: 10.3389/fmars.2018.00328
+
+### PyESPER_LIR 
+These are the first version of Python implementation of LIRv.3; ESPERv1.1, which use collections of interpolated linear networks. 
+
+### PyESPER_NN
+These are the first version of Python implementation of ESPERv1.1, which uses neural networks. 
+
+### PyESPER_Mixed
+These are the first version of Python implementation of ESPERv1.1, which is an average of the LIR and NN estimates. 
+
+## Basic Use
+
+### Requirements
+For the present version, you will need to download the repository along with the affiliated neural network files within the [NeuralNetworks](https://github.com/LarissaMDias/PyESPER/tree/main/NeuralNetworks) folder, and the [SimpleCantEstimateLR_full.csv](https://github.com/LarissaMDias/PyESPER/blob/main/SimpleCantEstimateLR_full.csv) file for estimates involving anthropogenic carbon calculations (pH and dissolved inorganic carbon). 
+
+To run the code, you will need numpy, pandas, seawater (now deprecated but necessary for consistency with ESPERv1), scipy, time, matplotlib, PyCO2SYS, importlib, statistics, and os packages.
+
+Please refer to the examples .py file for proper use.
+
+### Organization and Units
+The measurements are provided in molar units or if potential temperature or AOU are needed but not provided by the user. Scale differences from TEOS-10 are a negligible component of alkalinity estimate error. PyCO2SYS is required if pH on the total scale is a desired output variable.
+
+#### Input/Output dimensions:
+p:    Integer number of desired property estimate types (e.g., TA, pH, NO3-)
+
+n:    Integer number of desired estimate locations
+
+e:    Integer number of equations used at each location
+
+y:    Integer number of parameter measurement types provided by the user
+
+n*e:  Total number of estimates returned as an n by e array
+
+#### Required Inputs:
+
+##### DesiredVariables (required 1 by p list, where p specifies the desired variable(x) in string format): 
+List elements specify which variables will be returned. Excepting unitless pH, all outputs are in micromol per kg seawater. Naming of list elements must be exactly as demonstrated below (excamples ["TA"], ["DIC", "phosphate", "oxygen"]). 
+
+<ins>Desired Variable: List Element Name (String Format):</ins>
+
+Total Titration Seawater Alkalinity: TA
+
+Total Dissolved Inorganic Carbon: DIC
+
+in situ pH on the total scale: pH
+
+Phosphate: phosphate
+
+Nitrate: nitrate
+
+Silicate: silicate
+
+Dissolved Oxygen (O<sub>2</sub>):  oxygen
+
+##### Path (required string):
+Path directing Python to the location of saved/downloaded LIR files on the user's computer, if not in the current working directory (otherwise blank; e.g., '/Users/lara/Documents/Python' or ''). 
+
+##### OutputCoordinates (required n by 3 dictionary, where n are the number of desired estimate locations and the three dicstionary keys are longitude, latitude, and depth):
+Coordinates at which estimates are desired. The keys should be longitude (degrees E), latitude (degrees N), and positive integer depth (m), with dictionary keys named 'longitude', 'latitude', and 'depth' (ex: OutputCoordinates={"longitude": [0, 180, -50, 10], "latitude": [85, -20, 18, 0.5], "depth": [10, 1000, 0, 0]} or OutputCoordinates={"longitude": long, "latitude": lat, "depth": depth} when referring to a set of predefined lists or numpy arrays of latitude, longitude, and depth information. 
+
+##### PredictorMeasurements (required n by y dictionary, where n are the number of desired estimate locations and y are the dictionary keys representing each possible input): 
+Parameter measurements that will be used to estimate desired variables. Concentrations should be expressed as micromol per kg seawater unless PerKgSwTF is set to false in which case they should be expressed as micromol per L, temperature should be expressed as degrees C, and salinity should be specified with the unitless convention. NaN inputs are acceptable, but will lead to NaN estimates for any equations that depend on that parameter. The key order (y columns) is arbitrary, but naming of keys must adhere to the following convention (ex: PredictorMeasurements={"salinity": [35, 34.1, 32, 33], "temperature": [0.1, 10, 0.5, 2], "oxygen": [202.3, 214.7, 220.5, 224.2]} or PredictorMeasurements={'salinity': sal, 'temperature: temp, 'phosphate': phos, 'nitrate': nitrogen} when referring to predefined lists or numpy arrays of measurements:
+
+<ins>Input Parameter: Dictionary Key Name</ins>
+
+-Salinity: salinity
+
+-Temperature: temperature
+
+-Phosphate: phosphate
+
+-Nitrate: nitrate
+
+-Silicate: silicate
+
+-O<sub>2</sub>: oxygen
+
+#### Optional Inputs:
+All remaining inputs must be specified as sequential input argument pairs (e.g., "EstDates"=EstDates when referring to a predefined list of dates, 'Equations'=[1:16], pHCalcTF=True, etc.)
+
+##### EstDates (optional but recommended n by 1 list or 1 by 1 value, default 2002.0):
+A list of decimal dates for the estimates (e.g., July 1 2020 would be 2020.5). If only a single date is supplied that value is used for all estimates. It is highly recommended that date(s) be provided for estimates of DIC and pH. This version of the code will accept 1 by n inputs as well. 
+
+##### Equations (optional 1 by e list, default [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]):
+List indicating which equations will be used to estimate desired variables. If [] is input or the input is not specified then all 16 equations will be used. 
+
+#### Optional Inputs
+
+##### MeasUncerts (Optional n by y dictionary or 1 by y dictionary, default: [0.003 S, 0.003 degrees C T or potential temperature, 2% phosphate, 2% nitrate, 2% silicate, 1% AOU or O<sub>2</sub>]): 
+Dictionary of measurement uncertainties (see 'PredictorMeasurements' for units). Providing these estimates will improve PyESPER estimate uncertainties. Measurement uncertainties are a small p0art of PyESPER estimate uncertainties for WOCE-quality measurements. However, estimate uncertainty scales with measurement uncertainty, so it is recommended that measurement uncertainties be specified for sensor measurements. If this optional input argument is not provided, the default WOCE-quality uncertainty is assumed. If a 1 by y array is provided then the uncertainty estimates are assumed to apply uniformly to all input parameter measurements. Uncertainties should be presented with the following naming convention:
+
+<ins>Input Uncertainties: Key Name</ins>
+
+-Salinity: sal_u
+
+-Temperature: temp_u
+
+-Phosphate: phosphate_u
+
+-Nitrate: nitrate_u
+
+-Silicate: silicate_u
+
+-Oxygen: oxygen_u
+
+##### pHCalcTF (Optional boolean, default false):
+If set to true, PyESPER will recalculate the pH to be a better estimate of what the seawater pH value would be if calculated from TA and DIC instead of measured with purified m-cresol dye. This is arguably also a better estimate of the pH than would be obtained from pre-2011 measurements with impure dyes. See LIPHR paper for details. 
+
+##### PerKgSwTF (Optional boolean, default true):
+Many sensors provide measurements in micromol per L (molarity) instead of micromol per kg seawater. Indicate false if provided measurements are expressed in molar units (concentrations must be micromol per L if so). Outputs will remain in molal units regardless. 
+
+##### VerboseTF (Optional boolean, default true):
+Setting this to false will reduce the number of updates, warnings, and errors printed by PyESPER. An additional step can be taken before executing the PyESPER function (see examples) that will further reduce updates, warnings, and errors, if desired.
+
+#### Outputs:
+
+##### Estimates: 
+An n by e dictionary of estimates specific to the coordinates and parameter measurements provided as inputs. Units are micromoles per kg (equivalent to the deprecated microeq per kg seawater). Column names are the unique desired variable-equation combinations requested by the user. 
+
+##### Coefficients (LIRs only):
+An n by e dictionary of dictionaries of equation intercepts and coefficients specific to the coordinates and parameter measurements provided as inputs. Column names are the unique desired variable-equation combinations requested by the user. 
+
+##### Uncertainties: 
+An n by e dictionary of uncertainty estimates specific to the coordinates, parameter measurements, and parameter uncertaineis provided. Units are micromoles per kg (equivalent to the deprecated microeq per kg seawater). Column names are the unique desired variable-equation combinations requested by the user. 
+
+#### Missing Data:
+Should be indicated with a NaN. A NaN coordinate will yield NaN estimates for all equations at that coordinate. A NaN parameter value will yield NaN esitmates for all equations that require that parameter.  

pyesper-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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
+