PyESPER 1.0.0__py3-none-any.whl

PyESPER/process_netresults.py

@@ -0,0 +1,105 @@
+def process_netresults(Equations, code={}, df={}, EstAtl={}, EstOther={}):
+
+    """
+    Regional smoothing and processing net outputs
+
+    Inputs:
+        Equations: List of equations to use
+        code: Dictionary of input for each equation-variable scenario
+        df: Dictionary of coordinates and boolean indicators for regions
+        EstAtl: Dictionary of estimates for the Atlantic and Arctic
+            for each combination
+        EstOther: Dictionary of estimates for not Atlantic and Arctic,
+            for each combination
+
+    Output:
+        Estimate: Dictionary of estimates for each combination
+    """
+
+    import numpy as np
+
+    # Function to provide the mean of values when needed
+    def process_estimates(estimates):
+        keys = list(estimates.keys())
+        values = list(estimates.values())
+        result = {}
+        for i, key in enumerate(keys):
+            result[key] = [np.mean(values[i][v]) for v in range(len(values[0]))]
+        return result
+
+    Esta = process_estimates(EstAtl)
+    Esto = process_estimates(EstOther)
+
+    # Processing regionally in the Atlantic and Bering
+    EstA, EstB, EB2, ESat, ESat2, ESaf, Estimate  = {}, {}, {}, {}, {}, {}, {}
+
+    for i in code:
+        code[i]["AAInds"] = df["AAInds"]
+        code[i]["BeringInds"] = df["BeringInds"]
+        code[i]["SAtlInds"] = df["SAtlInds"]
+        code[i]["SoAfrInds"] = df["SoAfrInds"]
+
+    for codename, codedata in code.items():
+        # Defining empty lists for data from each regions
+        Estatl, Estb, eb2, Estsat, esafr = [], [], [], [], []
+        aainds, beringinds, satlinds, latitude, safrinds = (
+            codedata[key] for key in ["AAInds", "BeringInds", "SAtlInds", "Latitude", "SoAfrInds"]
+        )
+        Estatl = [Esta[codename][i] if aa_ind else Esto[codename][i] for i, aa_ind in enumerate(aainds)]
+        
+        # Smoothing for the Atlantic
+        for lenatl in range(0, len(Estatl)):
+            repeated_values = (latitude[lenatl]-62.5)/7.5
+            B = np.tile(repeated_values, (1, len(Equations)))
+            C = Esta[codename][lenatl]
+            B1 = C * B
+            repeated_values2 = (70-latitude[lenatl])/7.5
+            D = np.tile(repeated_values2, (1, len(Equations)))
+            E = Esto[codename][lenatl]
+            B2 = E * D
+            Estb.append(B1[0][0] + B2[0][0])
+    
+        eb2 = [Estb[j] if b_ind else Estatl[j] for j, b_ind in enumerate(beringinds)]
+        # Smoothing for the Bering
+        for n in range(0, len(satlinds)):   
+            repeated_values = (latitude[n]+44)/10
+            F1 = Esta[codename][n]
+            F = np.tile(repeated_values, (1, len(Equations)))
+            G1 = F1 * F
+            repeated_values2 = (-34-latitude[n])/10
+            H1 = Esto[codename][n]
+            H = np.tile(repeated_values2, (1, len(Equations)))
+            G2 = H1 * H
+            Estsat.append(G1[0][0] + G2[0][0])
+
+        EstA[codename], EstB[codename], EB2[codename], ESat[codename] = Estatl, Estb, eb2, Estsat
+        
+    # Regional processing for S. Atlantic
+        ESat2[codename] = [
+            ESat[codename][i] if satlinds[i] == "True" else EB2[codename][i]
+            for i in range(len(satlinds))
+        ]
+            
+    # Regional processing for S. Africa
+        for s in range(0, len(safrinds)):
+            repeated_values = (27-df["Lon"][s])/8
+            F1 = ESat2[codename][s]
+            F = np.tile(repeated_values, (1, len(Equations)))
+            G1 = F1*F
+            repeated_values2 = (df["Lon"][s]-19)/8
+            H1 = Esto[codename][s]
+            H = np.tile(repeated_values2, (1, len(Equations)))
+            G2 = H1 * H
+            esafr.append(G1[0][0] + G2[0][0])
+            
+        ESaf[codename] = esafr
+
+        Estimate[codename] = [
+            ESaf[codename][i] if safrinds[i] == "True" else ESat2[codename][i]
+            for i in range(len(safrinds))
+        ]
+        
+    # Bookkeeping blanks back to NaN as needed
+    Estimate = {k: ('NaN' if v == '' else v) for k, v in Estimate.items()}
+            
+    return Estimate

PyESPER/run_nets.py

@@ -0,0 +1,85 @@
+def run_nets(DesiredVariables, Equations, code={}):
+
+    """
+    Running neural nets
+
+    Inputs:
+        DesiredVariables: List of variables for estimates
+        Equations: List of desired equations
+        code: Dictionary of preprocessed measurements
+
+    Outputs:
+        EstAtl: Dictionary of estimates for the Atlantic and Arctic
+            Oceans
+        EstOther: Dictionary of estimates for not Altnatic/Arctic
+    """
+
+    import importlib
+    import numpy as np
+
+    # Predefining dictionaries to populate
+    EstAtl, EstOther = {}, {}
+    P, Sd, Td, Ad, Bd, Cd = {}, {}, {}, {}, {}, {}
+
+    # Calculating inputs for nets and formatting them
+    for name, value in code.items():
+        cosd = np.cos(np.deg2rad(value["Longitude"] - 20)).tolist()
+        sind = np.sin(np.deg2rad(value["Longitude"] - 20)).tolist()
+        lat, depth = value["Latitude"].tolist(), value["Depth"].tolist()
+        # Convert columns to lists of floats
+        Sd[name] = value["S"].astype(float).tolist()
+        Td[name] = value["T"].astype(float).tolist()
+        Ad[name] = value["A"].astype(float).tolist()
+        Bd[name] = value["B"].astype(float).tolist()
+        Cd[name] = value["C"].astype(float).tolist()
+
+   # Define a mapping from equations to the list of variables
+    equation_map = {
+        1: ["Sd", "Td", "Ad", "Bd", "Cd"],
+        2: ["Sd", "Td", "Ad", "Cd"],
+        3: ["Sd", "Td", "Bd", "Cd"],
+        4: ["Sd", "Td", "Cd"],
+        5: ["Sd", "Td", "Ad", "Bd"],
+        6: ["Sd", "Td", "Ad"],
+        7: ["Sd", "Td", "Bd"],
+        8: ["Sd", "Td"],
+        9: ["Sd", "Ad", "Bd", "Cd"],
+        10: ["Sd", "Ad", "Cd"],
+        11: ["Sd", "Bd", "Cd"],
+        12: ["Sd", "Cd"],
+        13: ["Sd", "Ad", "Bd"],
+        14: ["Sd", "Ad"],
+        15: ["Sd", "Bd"],
+        16: ["Sd"]
+    }
+        
+    # Create the correct vector for each equation case
+    for e in Equations:
+        for v in DesiredVariables:
+            name = v + str(e)
+            # Get the corresponding variables for the equation
+            variables = [locals()[var][name] for var in equation_map[e]]
+            P[name] = [[[cosd, sind, lat, depth] + variables]]
+            netstimateAtl, netstimateOther = [], []
+            for n in range(1, 5):   
+                fOName = f"NeuralNetworks.ESPER_{v}_{e}_Other_{n}"
+                fAName = f"NeuralNetworks.ESPER_{v}_{e}_Atl_{n}"
+                moda = importlib.import_module(fAName)
+                modo = importlib.import_module(fOName)
+                from importlib import reload
+                reload(moda)
+                reload(modo)   
+                # Running the nets
+                netstimateAtl.append(moda.PyESPER_NN(P[name]))
+                netstimateOther.append(modo.PyESPER_NN(P[name]))
+        
+            # Process estimates for Atlantic and Other regions
+            EstAtlL = [[netstimateAtl[na][0][eatl] for na in range(4)] for eatl in range(len(netstimateAtl[0][0]))]
+            EstOtherL = [[netstimateOther[no][0][eoth] for no in range(4)] for eoth in range(len(netstimateOther[0][0]))]
+        
+            # Store the result
+            EstAtl[name] = EstAtlL
+            EstOther[name] = EstOtherL
+            
+    return EstAtl, EstOther
+

PyESPER/simplecantestimatelr.py

@@ -0,0 +1,43 @@
+def simplecantestimatelr(EstDates, longitude, latitude, depth):
+
+    """
+    Simple estimate of contribution of anthropogenic carbon to pH and DIC estimates.
+
+    Inputs:
+        EstDates: List of dates for which estimates will be made
+        longitude:
+
+    Ouptuts:
+        CantMeas: List of anthropogenic carbon estimates
+        Cant2002: List of anthropogenic carbon estimates for 2002
+    """
+
+    import numpy as np
+    import pandas as pd
+    from scipy.interpolate import griddata
+
+    # Load interpolation points and values
+    CantIntPoints = pd.read_csv('SimpleCantEstimateLR_full.csv')
+    pointsi = (
+        CantIntPoints['Int_long'] * 0.25,
+        CantIntPoints['Int_lat'],
+        CantIntPoints['Int_depth'] * 0.025,
+    )
+    values = CantIntPoints['values']
+
+    # Scale input coordinates
+    pointso = (
+        np.array(longitude) * 0.25,
+        np.array(latitude),
+        np.array(depth) * 0.025,
+    )
+
+    # Interpolate and compute Cant2002
+    Cant2002 = griddata(pointsi, values, pointso, method='linear')
+
+    # Adjust for estimation dates
+    EstDates = np.asarray(EstDates)
+    CantMeas = Cant2002 * np.exp(0.018989 * (EstDates - 2002))
+
+    return CantMeas, Cant2002
+

PyESPER/temperature_define.py

@@ -0,0 +1,48 @@
+def temperature_define(
+    DesiredVariables, 
+    PredictorMeasurements, 
+    InputAll, 
+    **kwargs
+):
+
+    """ 
+   A small function to define temperature as needed and adjust
+        InputAll and PredictorMeasurements acccordingly.
+
+    Inputs:
+        DesiredVariables: List of desired output variables
+        PredictorMeasurements: Dictionary of user input measurements for predictors
+        InputAll: Dictionary of pre-adjusted and combined input and defined data
+        **kwargs: Please see README for more information
+
+    Ouputs:
+        PredictorMeasurements: Dictionary of user input measurements, adjusted for temperature
+            as needed
+        InputAll: Combined and processed necessary data to run the LIR, adjusted now for
+            temperature as needed
+    """
+
+    import numpy as np
+
+    n = max(len(v) for v in PredictorMeasurements.values()) # Recalculating number of required estimates
+
+    # Printing a custom warning if temperature is absent but needed
+    if "EstDates" in kwargs and "pH" in DesiredVariables:
+        if "temperature" not in PredictorMeasurements:
+            print(
+                "Warning: Carbonate system calculations will be used to adjust the pH, but no temperature is"
+                "specified so 10 C will be assumed. If this is a poor estimate for your region, consider supplying"
+                "your own value in the PredictorMeasurements input."
+            )
+            # Assuming temperature is 10 C if not defined
+            Temperature = np.full(n, 10)
+        else:
+            # Reading in temperature if defined
+            Temperature = np.array(InputAll["Temperature"])
+
+        # Adjusting dictionaries for the updated temperature definition
+        PredictorMeasurements["temperature"] = Temperature
+        InputAll["temperature"] = Temperature
+
+    return PredictorMeasurements, InputAll
+    

pyesper-1.0.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: PyESPER
+Version: 1.0.0
+Summary: Python version of ESPERv1
+Author: LMD
+Author-email: lmdias@uw.edu
+Requires-Dist: numpy
+Requires-Dist: seawater
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: PyCO2SYS
+Requires-Dist: pandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: requires-dist
+Dynamic: summary

pyesper-1.0.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+PyESPER/__init__.py,sha256=YnGqTco75ge10rdvEZXdS_zKR3yzSg6a1eVtD2BYqSs,1140
+PyESPER/adjust_pH_DIC.py,sha256=k5VVI-QxOF2ySQjevvph8V769QoJ-gXo7RwpS8whLv8,3278
+PyESPER/coefs_AAinds.py,sha256=ay8VWvd2ijYl4Z8w6PJqrNqz2V_BxBLzFJAgLMFHLXM,2091
+PyESPER/defaults.py,sha256=-8oX8Zc43ga74DZDgR3isOcBDpeVP_wLHQILfCtQTio,3141
+PyESPER/define_polygons.py,sha256=c3DbtwrdF5HhZ3WAqp76h3Xt22sRitZ-HkP7iT6QsuQ,2798
+PyESPER/emlr_estimate.py,sha256=ZErziQzl1oVoYXMr0Q7JZ5ruYy1kLq4TBjVBhSElfd0,6177
+PyESPER/emlr_nn.py,sha256=o2tDMXMKyDTvIBjvw4UBQKJQZU-POet1uobcXYcCGhw,1583
+PyESPER/errors.py,sha256=ApDeJOdXyDNMj2dgcL1JI6QLuXD7AYfWntHe1lM5qTA,2486
+PyESPER/fetch_data.py,sha256=GpLRRCzBboZ8h61ZE7kE-SFSBjk-xc0YbLipxyvDQ_A,1698
+PyESPER/fetch_polys_NN.py,sha256=qJMCAjBsWI0_xq72cs_BXCKRYvmFoWn0BXJkj9O3Gd8,413
+PyESPER/final_formatting.py,sha256=kcpttKqMUo4bruGiWGhqO_iZFpNVvGuj-4WNOUYaV_Y,828
+PyESPER/input_AAinds.py,sha256=I_drT8gQPd4U_iTR2s4KZNNqM-dSNo-7d7-Y8Nom1DM,4721
+PyESPER/inputdata_organize.py,sha256=F41OHSD7TeA9PYNx44O9Tt1F2gH0OyZ4NFL_zjAZCNs,1734
+PyESPER/interpolate.py,sha256=yL-4ePBQRbujq6aSeudlh65ArFsu5SxfuiGFtBRajLg,2283
+PyESPER/iterations.py,sha256=UgInZxYIZEjlbLhhDCxHAAqu492wyjLOV4RQN7wHhz0,11016
+PyESPER/lir.py,sha256=uKOMCMZeeKu69mO0Cj4m8ctz7U5BhzmxGUctwtryIpI,5966
+PyESPER/lir_uncertainties.py,sha256=PbedM_F-G1vQa1kdx9B6LdnYQ1NZV5vxZxRqItiyacI,4212
+PyESPER/mixed.py,sha256=TO1VVF0nBBAYzLuSwqVL4s7-5RN0gq_NUH9W_T2cUzY,1877
+PyESPER/nn.py,sha256=tJX2ziBe2zg7uqHD6w0trdkpwl6UnJ2_EFV48ZWKqlI,4244
+PyESPER/organize_data.py,sha256=40rBZT7PUWXnO2PzhniOjzGgYT5rRxzr3RNAN4OgqEE,15422
+PyESPER/organize_nn_output.py,sha256=j2gZyrDOUq3x7RU9G3XyVhYNrsrJctU3EFvJBOh33OE,8754
+PyESPER/pH_DIC_nn_adjustment.py,sha256=hE6tcW0ma-5MChycWC0I1wArmgg7ccOHTgaqBhKy6V4,8346
+PyESPER/pH_adjcalc.py,sha256=hj-dm4RAQFChzK0OS2tmVmkr3B_c5kb60EVSuNakQQw,1392
+PyESPER/pH_adjustment.py,sha256=JattOCeBY5lle0KXYOlVI4IXuAeU9EqKelscMKxWYbQ,7806
+PyESPER/process_netresults.py,sha256=8azrlkL8UrXmIBgQusXnQjaCNRAOkk1g92HfuvW9H28,4064
+PyESPER/run_nets.py,sha256=vD-cnIe0gmOkLwun1dI6o3Ima7WoLDdmxg1ns7rwP00,3221
+PyESPER/simplecantestimatelr.py,sha256=tKLbP8INYYgngfqHSOL_nhqYFXVIAi4BG4HGBpDArp0,1202
+PyESPER/temperature_define.py,sha256=d6iEVwtvDLPNPQKWN4e-pWmI4E8i10aTVnQDQiann4A,1879
+pyesper-1.0.0.dist-info/METADATA,sha256=lmdWzuq2oSR5yj7QKnovay4B6QVCGfVAjs3_7D1S-XI,342
+pyesper-1.0.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+pyesper-1.0.0.dist-info/entry_points.txt,sha256=HUU4cSedQ0gjEPqylS2XRZyJYlfQorLWqz7Giyj-H20,74
+pyesper-1.0.0.dist-info/top_level.txt,sha256=TlLY5TlArHVpCWb0rItFEzqlQtDSwpNU-Aq1NcZeUMI,8
+pyesper-1.0.0.dist-info/RECORD,,

pyesper-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyesper-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+lir = PyESPER:lir
+mixed = PyESPER:mixed
+nn = PyESPER:nn

pyesper-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+PyESPER