PyESPER 1.0.0__py3-none-any.whl

PyESPER/organize_nn_output.py

@@ -0,0 +1,266 @@
+def organize_nn_output(Path, DesiredVariables, OutputCoordinates={}, PredictorMeasurements={},  **kwargs):
+
+    """
+    Iteratively calculate uncertainties
+
+    Inputs:
+        Path: User-defined computer path
+        Desired Variables: List of variables requested
+        OutputCoordinates: Dictionary of geographic coordinates
+        PredictorMeasurements: Dictionary of predictor measurements
+        **kwargs: Please see README
+
+    Outputs:
+        Uncertainties: Dictionary of uncertainty estimates for each
+            equation-variable combination
+    """
+
+    import numpy as np
+    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.define_polygons import define_polygons
+    from PyESPER.run_nets import run_nets
+    from PyESPER.process_netresults import process_netresults
+    from PyESPER.emlr_nn import emlr_nn
+
+    # Predefine output lists
+    PD_final, DPD_final, Unc_final, DUnc_final = [], [], [], []
+    emlr = []
+
+    # Rerun nets for each variable
+    for d, var in enumerate(DesiredVariables):
+        Pertdv, DPertdv, Unc, DUnc = [], [], [], []
+        var = [var] # Wrap single variable in a list
+        keys = ["sal_u", "temp_u", "phosphate_u", "nitrate_u", "silicate_u", "oxygen_u"]
+
+        Equations, n, VerboseTF, EstDates, C, PerKgSwTF, MeasUncerts = defaults(
+            var,
+            PredictorMeasurements,
+            OutputCoordinates,
+            **kwargs
+        )
+        Uncertainties_pre, DUncertainties_pre = measurement_uncertainty_defaults(
+            n,
+            PredictorMeasurements,
+            MeasUncerts
+        )
+    
+        InputAll = inputdata_organize( 
+            EstDates,
+            C,
+            PredictorMeasurements,
+            Uncertainties_pre
+        )
+    
+        PredictorMeasurements, InputAll = temperature_define(
+            var,
+            PredictorMeasurements,
+            InputAll,
+            **kwargs
+        )
+            
+        code, unc_combo_dict, dunc_combo_dict = iterations(
+            var,
+            Equations,
+            PerKgSwTF,
+            C,
+            PredictorMeasurements,
+            InputAll,
+            Uncertainties_pre,
+            DUncertainties_pre
+        )
+
+        df = define_polygons(C)
+            
+        EstAtl, EstOther = run_nets(var, Equations, code)
+            
+        Estimate = process_netresults(
+            Equations,
+            code,
+            df,
+            EstAtl,
+            EstOther
+        )
+            
+        EMLR = emlr_nn(
+            Path,
+            var,
+            Equations,
+            OutputCoordinates,
+            PredictorMeasurements
+        )
+      
+        emlr.append(EMLR)
+        names = list(PredictorMeasurements.keys())
+        PMs = list(PredictorMeasurements.values())
+
+        # Replace "nan" with 0 in PMs using list comprehensions
+        PMs_nonan = [[0 if val == "nan" else val for val in pm] for pm in PMs]
+        
+        # Transpose PMs_nonan
+        PMs = np.transpose(PMs_nonan)
+            
+        PMs3, DMs3 = {}, {}
+            
+        for pred in range(len(PredictorMeasurements)):
+            num_coords = len(OutputCoordinates["longitude"])
+            num_preds = len(PredictorMeasurements)
+            
+            # Initialize perturbation arrays
+            Pert = np.zeros((num_coords, num_preds))
+            DefaultPert = np.zeros((num_coords, num_preds))
+            
+            # Populate perturbation arrays
+            Pert[:, pred] = Uncertainties_pre[keys[pred]]
+            DefaultPert[:, pred] = DUncertainties_pre[keys[pred]]
+            
+            # Apply perturbations
+            PMs2 = PMs + Pert
+            DMs2 = PMs + DefaultPert
+        
+            # Update PMs3 and DMs3 dictionaries
+            for col, name in enumerate(names):
+                PMs3[name] = PMs2[:, col].tolist()
+                DMs3[name] = DMs2[:, col].tolist()
+        
+            # Run preprocess_applynets for perturbed and default data
+            VTF = False
+            Eqs2, n2, VerbTF2, EstDates2, C2, PerKgSwTF2, MeasUncerts2 = defaults(
+                var,
+                PMs2,
+                OutputCoordinates,
+                Equations=Equations,
+                EstDates=EstDates,
+                VerboseTF = VTF,
+            )
+            U_pre2, DU_pre2 = measurement_uncertainty_defaults(
+                n2,
+                PMs3,
+                MeasUncerts2
+            )
+            InputAll2 = inputdata_organize(
+                EstDates2,
+                C2,
+                PMs3,
+                U_pre2
+            )
+            InputAll3 = inputdata_organize(   
+                EstDates2,
+                C2,
+                DMs3,
+                U_pre2
+            )
+            PMs3, InputAll2 = temperature_define(
+                var,
+                PMs3,
+                InputAll2,
+                **kwargs
+            )
+            DMs3, InputAll3 = temperature_define(
+                var,
+                DMs3,
+                InputAll3,
+                **kwargs
+            )
+            code2, unc_combo_dict2, dunc_combo_dict2 = iterations(
+                var,
+                Eqs2,
+                PerKgSwTF2,
+                C2,  
+                PMs3, 
+                InputAll2,
+                U_pre2,
+                DU_pre2   
+            )
+            code3, unc_combo_dict3, dunc_combo_dict3 = iterations(
+                var,  
+                Eqs2,
+                PerKgSwTF2,
+                C2, 
+                DMs3,
+                InputAll3,
+                U_pre2, 
+                DU_pre2
+            )
+            df2 = define_polygons(C2)
+            EstAtl2, EstOther2 = run_nets(
+                var,
+                Eqs2,   
+                code2
+            )
+            EstAtl3, EstOther3 = run_nets(
+                var, 
+                Eqs2,
+                code3
+            )
+            PertEst = process_netresults(
+                Eqs2,  
+                code2,    
+                df2,
+                EstAtl2,
+                EstOther2
+            )
+            DefaultPertEst = process_netresults(
+                Eqs2,
+                code3,
+                df2,
+                EstAtl3,
+                EstOther3
+            )
+            
+            # Extract estimates and perturbation results
+            estimates = [np.array(v) for v in Estimate.values()]
+            pertests = [np.array(v) for v in PertEst.values()]
+            defaultpertests = [np.array(v) for v in DefaultPertEst.values()]
+             
+            # Initialize result lists
+            PertDiff, DefaultPertDiff, Unc_sub2, DUnc_sub2 = [], [], [], []
+
+            for c in range(len(Equations)):
+            # Compute differences and squared differences using numpy
+                PD = estimates[c] - pertests[c]
+                DPD = estimates[c] - defaultpertests[c]
+                Unc_sub1 = (estimates[c] - pertests[c])**2
+                DUnc_sub1 = (estimates[c] - defaultpertests[c])**2
+                
+               # Append results
+                PertDiff.append(PD)
+                DefaultPertDiff.append(DPD)
+                Unc_sub2.append(Unc_sub1)
+                DUnc_sub2.append(DUnc_sub1)
+            Pertdv.append(PertDiff)
+            DPertdv.append(DefaultPertDiff)
+            Unc.append(Unc_sub2)
+            DUnc.append(DUnc_sub2)
+        PD_final.append(Pertdv)
+        DPD_final.append(DPertdv)
+        Unc_final.append(Unc)
+        DUnc_final.append(DUnc)
+            
+    # Compute final uncertainty propagation
+            
+    est = [np.array(v) for v in Estimate.values()]
+    emlr_combined = {k: v for d in emlr for k, v in d.items()}
+    Uncertainties = {}
+    for dv in range(0, len(DesiredVariables)):
+        dvu = []
+        for eq in range(0, len(Equations)):
+            sumu = []
+            name = DesiredVariables[dv] + str(Equations[eq])
+            for n in range(0, len(est[0])):
+                # Collect uncertainty contributions from each perturbation
+                u =  np.array([Unc_final[dv][pre][eq][n] for pre in range(len(PredictorMeasurements))])
+                du = np.array([DUnc_final[dv][pre][eq][n] for pre in range(len(PredictorMeasurements))])
+                eu = emlr_combined[name][n]
+                # Final uncertainty formula
+                total_uncertainty = np.sqrt(np.sum(u) - np.sum(du) + eu**2)
+                sumu.append(total_uncertainty)
+            dvu.append(sumu)
+            
+            Uncertainties[name] = dvu[0]
+        
+    return Uncertainties
+

PyESPER/pH_DIC_nn_adjustment.py

@@ -0,0 +1,189 @@
+def pH_DIC_nn_adjustment(Path, DesiredVariables, Estimates, YouHaveBeenWarnedCanth, OutputCoordinates={}, PredictorMeasurements={}, **kwargs):
+
+    """
+    Calculating the anthropogenic carbon component for DIC and pH, if needed
+
+    Inputs:
+        Path: Path for user computer
+        DesiredVariables: List of variables for which estimates are requested
+        Estimates: Dictionary of estimates for each equation-variable combination
+        YouHaveBeenWarnedCanth: Boolean for avoiding repeat warnings
+        OutputCoordinates: Dictionary of coordinates for requested estimates
+        PredictorMeasurements: Dictionary of measurements for calculations
+        **kwargs: Please see README for full information
+
+    Outputs:
+        Cant_adjusted: Dictionary of estimates adjusted for anthropogenic carbon
+            for each equation-variable combination
+    """
+
+    from PyESPER.simplecantestimatelr import simplecantestimatelr
+    import numpy as np
+    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.define_polygons import define_polygons
+    from PyESPER.run_nets import run_nets
+    from PyESPER.process_netresults import process_netresults
+    import seawater as sw
+    import PyCO2SYS as pyco2
+
+    # Interpreting kwargs and setting defaults if needed
+    VerboseTF = kwargs.get("VerboseTF", True)
+    n = max(len(v) for v in OutputCoordinates.values())
+    if "EstDates" in kwargs:
+        d = np.array(kwargs["EstDates"])
+        EstDates = (
+            [item for sublist in [kwargs["EstDates"]] * (n + 1) for item in sublist]
+            if len(d) != n else list(d)
+        )
+    else:
+        EstDates = [2002.0] * n
+
+    # Predefining empty dictionary for results and parsing out estimates
+    Cant_adjusted = {}
+    combos2 = list(Estimates.keys())
+    values2 = list(Estimates.values())
+
+    # Only if dates are available and if needed, continue
+    if "EstDates" in kwargs and ("DIC" in DesiredVariables or "pH" in DesiredVariables):
+        if not YouHaveBeenWarnedCanth:   
+            if VerboseTF:
+                print("Estimating anthropogenic carbon for PyESPER_NN.")
+            longitude = np.mod(OutputCoordinates["longitude"], 360)
+            latitude = np.array(OutputCoordinates["latitude"])
+            depth = np.array(OutputCoordinates["depth"])
+            Cant, Cant2002 = simplecantestimatelr(EstDates, longitude, latitude, depth)
+            YouHaveBeenWarnedCanth = True
+    
+        for combo, a in zip(combos2, values2):
+            a = np.array(a, dtype=float)
+            if combo.startswith("DIC"):
+                a = np.where(np.isnan(a), "nan", a + Cant - Cant2002)
+                Cant_adjusted[combo] = a.tolist()
+            else:
+                Cant_adjusted[combo] = a.tolist()
+        
+        # Extra perturbation for pH
+        if "pH" in DesiredVariables:   
+            warning = []
+            for combo, values in zip (combos2, values2):
+                if combo.startswith("pH"):
+                    salinity = PredictorMeasurements["salinity"]
+                    PM_pH = {"salinity": salinity}
+                    eq = [16]
+                    _, n, _, EstDates, C, PerKgSwTF, MeasUncerts = defaults(
+                        ["TA"],
+                        PM_pH,
+                        OutputCoordinates,
+                        **kwargs
+                    )
+                    U_pre, DU_pre = measurement_uncertainty_defaults(
+                        n,
+                        PM_pH,
+                        MeasUncerts
+                    )
+                    InputAll = inputdata_organize(
+                        EstDates,
+                        C,
+                        PM_pH,
+                        U_pre
+                    )
+                    PM_pH, InputAll = temperature_define(
+                        ["TA"],
+                        PM_pH,
+                        InputAll,
+                        **kwargs
+                    )
+                    code, unc_combo_dict, dunc_combo_dict = iterations(
+                        ["TA"],
+                        eq,
+                        PerKgSwTF,
+                        C,
+                        PM_pH,
+                        InputAll,
+                        U_pre,
+                        DU_pre 
+                    )
+                    df = define_polygons(C)
+                    EstAtl, EstOther = run_nets(
+                        ["TA"],
+                        eq,
+                        code
+                    )
+                    alkest = process_netresults(
+                        eq,
+                        code,
+                        df,
+                        EstAtl,
+                        EstOther
+                     )
+                    EstAlk = np.array(alkest["TA16"])
+                    EstSi = EstP = [0] * len(EstAlk)
+                    Pressure = sw.pres(OutputCoordinates["depth"], OutputCoordinates["latitude"])
+                    Est = np.array(values)
+                        
+                    # CO2SYS calculations
+                    Out = pyco2.sys(
+                        par1=EstAlk,
+                        par2=Est,
+                        par1_type=1,
+                        par2_type=3,
+                        salinity=salinity,
+                        temperature=PredictorMeasurements["temperature"],
+                        temperature_out=PredictorMeasurements["temperature"],
+                        pressure=Pressure,
+                        pressure_out=Pressure,
+                        total_silicate=EstSi,
+                        total_phosphate=EstP,
+                        opt_total_borate= 2
+                    )
+                    DICadj = Out["dic"] + Cant - Cant2002
+                    OutAdj = pyco2.sys(
+                        par1=EstAlk,
+                        par2=DICadj,
+                        par1_type=1,
+                        par2_type=2,
+                        salinity=salinity,
+                        temperature=PredictorMeasurements["temperature"],
+                        temperature_out=PredictorMeasurements["temperature"],
+                        pressure=Pressure,
+                        pressure_out=Pressure,
+                        total_silicate=EstSi,
+                        total_phosphate=EstP,
+                        opt_total_borate=2
+                    )   
+                    pHadj = OutAdj["pH"] 
+                    
+                    if any(np.isnan(pHadj)):
+                        warning_message = (
+                            "Warning: CO2SS took >20 iterations to converge. The correcponding estimate(s) will be NaN. "
+                            "This typically happens when ESPER_NN is pooorly suited for estimating water with the given properties "
+                            "(e.g., very high or low salinity or estimates in marginal seas)."
+                        )
+                        warning.append(warning_message)
+                    else:
+                        pHadj = np.array(values)
+                        
+                    Cant_adjusted[combo] = pHadj.tolist()
+                        
+                # Print warnings if any
+                if warning:
+                    print(warning[0])  
+                        
+    elif "EstDates" not in kwargs and ("DIC" or "pH" in DesiredVariables) and VerboseTF and not YouHaveBeenWarnedCanth:
+        print("Warning: DIC or pH is a requested output but the user did not provide dates for the desired estimates. The estimates will be specific to 2002.0 unless the optional EstDates input is provided (recommended).")
+        YouHaveBeenWarnedCanth = True
+                        
+    if kwargs.get("pHCalcTF") and "pH" in DesiredVariables:
+        if VerboseTF:
+            print("Recalculating the pH to be appropriate for pH values calculated from TA and DIC.")
+        for combo, pH_values in zip(combos2, values2):
+            if combo.startswith("pH"):
+                pH_adjcalc_Est = [(pH + 0.3168) / 1.0404 for pH in pH_values]
+                Cant_adjusted[combo] = pH_adjcalc_Est
+                        
+    return Cant_adjusted
+

PyESPER/pH_adjcalc.py

@@ -0,0 +1,36 @@
+def pH_adjcalc(DesiredVariables, VerboseTF, Est_pre={}, Cant_adjusted={}, **kwargs):
+
+    """
+    Calculating pH adjustment if units are not in molal format
+
+    Inputs:
+        DesiredVariables: List of variables requested
+        VerboseTF: Boolean option to suppress warnings
+        Est_pre: Dictionary of estimates thus far for each variable equation combination
+        Cant_adjusted: Dictionary of estimates adjusted for anthropogenic carbon for each
+            combination
+        **kwargs: Please see README for full information
+
+    Outputs:
+        Cant_adjusted: Dictionary of estimates adjusted for anthropogenic carbon
+        combos2: List of equation case-desired variable combinations
+        values2: List of estimates
+    """
+
+    combos2 = list(Est_pre.keys())
+    values2 = list(Est_pre.values())
+
+    if kwargs.get("pHCalcTF") and "pH" in DesiredVariables:
+        if VerboseTF:
+            print("Recalculating the pH to be appropriate for pH values calculated from TA and DIC.")
+
+        for combo in range(0, len(combos2)):
+            if combos2[combo].startswith("pH"):
+                pH_adjcalc_Est = []
+                pH_adjcalc = values2[combo]
+                for v in pH_adjcalc:
+                    pH_adjcalc_Est.append((pH_adjcalc[v]+0.3168)/1.0404)
+            Cant_adjusted[combos2[combo]] = pH_adjcalc_Est
+
+    return Cant_adjusted, combos2, values2
+

PyESPER/pH_adjustment.py

@@ -0,0 +1,179 @@
+def pH_adjustment(
+    Path,
+    DesiredVariables,
+    Dates, 
+    Cant, 
+    Cant2002,
+    PerKgSwTF, 
+    Cant_adjusted={},
+    Est_pre={}, 
+    PredictorMeasurements={}, 
+    OutputCoordinates={}, 
+    C={},  
+    Uncertainties_pre={}, 
+    DUncertainties_pre={},
+    **kwargs
+):
+
+    """
+    Adjusting pH for anthropogenic carbon in the second of three Cant adjustment
+        scripts
+
+    Inputs:
+        Path: User-defined computer path
+        DesiredVariables: List of desired variables to estimate
+        Dates: List of dates for measurements
+        Cant: Numpy array of anthropogenic carbon estimates for each estimate
+        Cant2002: Numpy array of anthropogenic carbon estimates for each
+            estimate for the year 2002
+        PerKgSwTF: Boolean for whether measurements were in molar or molal units
+        Cant_adjusted: Dictionary of estimates adjusted for Cant
+        Est_pre: Dictionary of estimates for each combination
+        PredictorMeasurements: Dictionary of measurements for estimates
+        OutputCoordinates: Dictionary of geographic coordinates for estimates
+        C: Dictionary of adjusted coordinates for estimates
+        Uncertainties_pre: Dictionary of measurement uncertainties for estimates
+        DUncertainties_pre: Dictionary of default measurement uncertainties for
+            estimates
+        **kwargs: Please see README
+
+    Output:
+        Cant_adjusted: Dictionary of adjusted values for Cant for each combination
+    """
+
+    import numpy as np
+    import seawater as sw
+    import PyCO2SYS as pyco2
+    from PyESPER.inputdata_organize import inputdata_organize
+    from PyESPER.temperature_define import temperature_define
+    from PyESPER.iterations import iterations
+    from PyESPER.fetch_data import fetch_data
+    from PyESPER.input_AAinds import input_AAinds
+    from PyESPER.coefs_AAinds import coefs_AAinds
+    from PyESPER.interpolate import interpolate
+    from PyESPER.organize_data import organize_data
+        
+    # Finding the estimates within the dictionary
+    combos2 = list(Est_pre.keys())
+    values2 = list(Est_pre.values())
+        
+    # Setting the default warning message boolean and Verbose
+    YouHaveBeenWarnedCanth = False
+    VerboseTF = kwargs.get("VerboseTF", True)
+
+    # Proceed only if dates are provided and DIC or pH is requested
+    if "EstDates" in kwargs and ("DIC" in DesiredVariables or "pH" in DesiredVariables):
+        if "pH" in DesiredVariables:
+            warning = []
+            for combo, values in zip(combos2, values2):
+                if combo.startswith("pH"):
+                    # Rerunning LIRs for when pH is requested to obtain TA estimates
+                    # based only on salinity input
+                    salinity = PredictorMeasurements["salinity"]
+                    PM_pH = {"salinity": salinity}
+                    eq = [16]
+                    InputAll2 = inputdata_organize(
+                        Dates,
+                        C,
+                        PM_pH,
+                        Uncertainties_pre
+                    )
+                    PredictorMeasurements2, InputAll2 = temperature_define(
+                        ["TA"],   
+                        PM_pH,
+                        InputAll2,
+                        **kwargs
+                    )
+                    code, unc_combo_dict, dunc_combo_dict = iterations(
+                        ["TA"],
+                        eq,
+                        PerKgSwTF,
+                        C,
+                        PredictorMeasurements2,
+                        InputAll2,
+                        Uncertainties_pre,
+                        DUncertainties_pre
+                    )
+                    LIR_data = fetch_data(["TA"], Path)
+                    AAdata, Elsedata = input_AAinds(C, code)
+                    Gdf, CsDesired = coefs_AAinds(eq, LIR_data)
+                    aaLCs, aaInterpolants_pre, elLCs, elInterpolants_pre = interpolate(
+                        Gdf,  
+                        AAdata,
+                        Elsedata
+                    )
+                    alkest, _ = organize_data(
+                        aaLCs,
+                        elLCs,    
+                        aaInterpolants_pre,
+                        elInterpolants_pre,
+                        Gdf,
+                        AAdata,
+                        Elsedata
+                    )
+                    EstAlk = np.array(alkest["TA16"])
+                    EstAlk = np.transpose(EstAlk)
+                    EstSi = EstP = [0] * len(EstAlk)
+                    # Calculating pressure using the sw package
+                    Pressure = sw.pres(OutputCoordinates["depth"], OutputCoordinates["latitude"])
+                    Est = np.array(values)
+                    Est = np.transpose(Est)
+                    Est = Est[0]
+                    temperature = np.array(PredictorMeasurements["temperature"])
+                    # Now using CO2SYS to calculate DIC based on the above LIR results for TA
+                    # CO2SYS calculations
+                    kwargCO2 = {
+                        "par1":EstAlk,
+                        "par2":Est,
+                        "par1_type":1,
+                        "par2_type":3,
+                        "salinity":salinity,  
+                        "temperature":temperature,
+                        "temperature_out":temperature,
+                        "pressure":Pressure,
+                        "pressure_out":Pressure,
+                        "total_silicate":EstSi,
+                        "total_phosphate":EstP,
+                        "opt_total_borate":2}
+                    Out = pyco2.sys(**kwargCO2)
+                    DICadj = Out["dic"] + Cant - Cant2002
+                    
+                    # Using this DIC to calculate pH from CO2SYS
+                    kwargCO2_2 = {
+                        "par1":EstAlk,
+                        "par2":DICadj,
+                        "par1_type":1,
+                        "par2_type":2,
+                        "salinity":salinity,
+                        "temperature":temperature,
+                        "temperature_out":temperature,
+                        "pressure":Pressure,
+                       "pressure_out":Pressure,
+                        "total_silicate":EstSi,
+                        "total_phosphate":EstP,
+                        "opt_total_borate":2}
+                    OutAdj = pyco2.sys(**kwargCO2_2)
+                    pHadj = OutAdj["pH"]
+                        
+                    # Check for convergence warnings
+                    if np.isnan(pHadj).any():   
+                        warning_message = (
+                            "Warning: CO2SYS took >20 iterations to converge. The corresponding estimate(s) will be NaN. "
+                            "This typically happens when ESPER_LIR is poorly suited for estimating water with the given properties "
+                            "(e.g., very high or low salinity or estimates in marginal seas)."
+                        )
+                        warning.append(warning_message)
+                    # Append to adjusted Cant dictionary
+                    Cant_adjusted[combo] = pHadj.tolist()
+                        
+                # Print warnings if any
+                if warning:
+                    print(warning[0]) 
+                        
+    elif "EstDates" not in kwargs and ("DIC" or "pH" in DesiredVariables) and not VerboseTF and YouHaveBeenWarnedCanth:
+        print("Warning: DIC or pH is a requested output but the user did not provide dates for the desired esimtates. The estimates "
+            "will be specific to 2002.0 unless the optional EstDates input is provided (recommended).")
+
+        YouHaveBeenWarnedCanth = True
+                        
+    return Cant_adjusted