VolFe 0.4.1__tar.gz → 0.4.2__tar.gz

{volfe-0.4.1 → volfe-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: VolFe
-Version: 0.4.1
+Version: 0.4.2
 Summary: VolFe
 Author: Pip Liggins, Penny Wieser
 Author-email: Ery Hughes <ery.c.hughes@gmail.com>
@@ -15,7 +15,7 @@ Requires-Dist: gmpy2==2.2.1
 Requires-Dist: numpy<2
 Requires-Dist: pandas==2.2.3
 Requires-Dist: PySulfSat==1.0.6
-Requires-Dist: scipy
+Requires-Dist: scipy>=1.13.1
 Requires-Dist: tqdm==4.67.1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"

{volfe-0.4.1 → volfe-0.4.2}/pyproject.toml

@@ -24,7 +24,7 @@ dependencies = [
     "numpy<2",
     "pandas==2.2.3",
     "PySulfSat==1.0.6",
-    "scipy",
+    "scipy>=1.13.1",
     "tqdm==4.67.1",
 ]
 

{volfe-0.4.1 → volfe-0.4.2}/src/VolFe/__init__.py

@@ -1,23 +1,23 @@
 __author__ = "Ery Hughes, Pip Liggins, Penny Wieser"
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 
 # functions for calculating properties of the melt and gas
-from .melt_gas import *
+from .melt_gas import *  # noqa F401 F403
 
 # functions for variables that can be model depedent (e.g., solubility constants,
 # fugacity coefficients)
-from .model_dependent_variables import *
+from .model_dependent_variables import *  # noqa F401 F403
 
 # functions for calculating equilibrium speciation and concentration between melt ± gas
 # at given P and T
-from .equilibrium_equations import *
-from .differential_equations import *
+from .equilibrium_equations import *  # noqa F401 F403
+from .differential_equations import *  # noqa F401 F403
 
 # functions to calculate equilibrium isotope fractionation given melt ± gas composition
-from .batch_calculations import *
+from .batch_calculations import *  # noqa F401 F403
 
 # functions to run a calculations
-from .calculations import *
+from .calculations import *  # noqa F401 F403
 
 # functions to run calculations in batch mode
-from .batch_calculations import *
+from .batch_calculations import *  # noqa F401 F403

{volfe-0.4.1 → volfe-0.4.2}/src/VolFe/batch_calculations.py

@@ -1173,9 +1173,15 @@ def calc_gassing(
         P_sat_, P_sat_H2O_CO2_result = c.P_sat_H2O_CO2(
             PT, melt_wf, models, psat_tol, nr_step, nr_tol
         )
+        wm_H2Omol_, wm_OH_ = mg.wm_H2Omol_OH(PT, melt_wf, models)
+        wm_CO2carb_, wm_CO2mol_ = mg.wm_CO32_CO2mol(PT, melt_wf, models)
         conc = {
             "wm_H2O": P_sat_H2O_CO2_result["wm_H2O"],
             "wm_CO2": P_sat_H2O_CO2_result["wm_CO2"],
+            "wm_OH": wm_OH_,
+            "wm_H2Omol": wm_H2Omol_,
+            "wm_CO2mol": wm_CO2mol_,
+            "wm_CO2carb": wm_CO2carb_,
             "wm_H2": 0.0,
             "wm_CO": 0.0,
             "wm_CH4": 0.0,
@@ -1732,6 +1738,7 @@ def calc_gassing(
                         }
                         if dp_step < 1.0 or dp_step == 1.0:
                             if PT["P"] <= 10.0:
+                                print("P < 10 bar, trying P = 1 bar")
                                 PT["P"] = 1.0
                                 with warnings.catch_warnings():
                                     warnings.simplefilter(
@@ -1768,7 +1775,7 @@ def calc_gassing(
                                         )
                                     print(
                                         "solver failed, calculation aborted at P = ",
-                                        PT["P"],
+                                        last_successful_P,
                                         datetime.datetime.now(),
                                     )
                                     return results
@@ -1873,7 +1880,7 @@ def calc_gassing(
                         )
                     print(
                         "solver failed, calculation aborted at P = ",
-                        PT["P"],
+                        last_successful_P,
                         datetime.datetime.now(),
                     )
                     return results
@@ -2153,13 +2160,13 @@ def calc_gassing(
                 results_me = mg.melt_elements(melt_wf, bulk_wf, gas_mf)
                 if models.loc["gassing_direction", "option"] == "degas":
                     Wt_ = bulk_wf["Wt"]
-                    if results_me["wm_C"] < 1.0e-6:  # 1 ppm C
+                    if results_me["wm_C"] < 1.0e-7:  # 0.1 ppm C
                         results_me["wm_C"] = 0.0
-                    if results_me["wm_H"] < 1.0e-6:  # 1 ppm H
+                    if results_me["wm_H"] < 1.0e-7:  # 0.1 ppm H
                         results_me["wm_H"] = 0.0
-                    if results_me["wm_S"] < 1.0e-6:  # 1 ppm S
+                    if results_me["wm_S"] < 1.0e-7:  # 0.1 ppm S
                         results_me["wm_S"] = 0.0
-                    if results_me["wm_X"] < 1.0e-6:  # 1 ppm X
+                    if results_me["wm_X"] < 1.0e-7:  # 0.1 ppm X
                         results_me["wm_X"] = 0.0
                     bulk_wf = {
                         "C": results_me["wm_C"],
@@ -2211,7 +2218,7 @@ def calc_gassing(
                     "Wt": wt_ * (1.0 - Xst),
                 }
 
-            tqdmsteps.update(dp_step)
+            tqdmsteps.update(abs(dp_step))
 
             if models.loc["gassing_direction", "option"] == "regas":
                 if (PT["P"] + dp_step) >= final:
@@ -2768,26 +2775,26 @@ def calc_melt_S_oxybarometer(
         results_values_table_melt_vol = pd.DataFrame(
             [
                 [
-                    setup.loc[run, "H2O"],
-                    setup.loc[run, "CO2ppm"],
-                    setup.loc[run, "STppm"],
-                    setup.loc[run, "Xppm"],
+                    melt_wf["H2OT"] * 100.0,
+                    melt_wf["CO2"] * 1000000.0,
+                    melt_wf["ST"] * 1000000.0,
+                    melt_wf["X"] * 1000000.0,
                 ]
             ]
         )
         results_headers_table_sulfsat = pd.DataFrame(
             [
                 [
-                    "P_bar_sulf",
                     "SCSS_ppm",
                     "sulfide saturated",
+                    "P_bar_sulf",
                     "fO2_DFMQ_sulf",
                     "fO2_bar_sulf",
                     "Fe3+/FeT_sulf",
                     "S6+/ST_sulf",
-                    "P_bar_anh",
                     "SCAS_ppm",
                     "anhydrite saturated",
+                    "P_bar_anh",
                     "fO2_DFMQ_anh",
                     "fO2_bar_anh",
                     "Fe3+/FeT_anh",
@@ -2798,16 +2805,16 @@ def calc_melt_S_oxybarometer(
         results_values_table_sulfsat = pd.DataFrame(
             [
                 [
-                    sulfsat_results["P_sat_sulf"],
                     sulfsat_results["SCSS"],
                     sulfsat_results["sulf_sat"],
+                    sulfsat_results["P_sat_sulf"],
                     sulfsat_results["DFMQ_sulf"],
                     sulfsat_results["fO2_sulf"],
                     sulfsat_results["Fe3T_sulf"],
                     sulfsat_results["S6T_sulf"],
-                    sulfsat_results["P_sat_anh"],
                     sulfsat_results["SCAS"],
                     sulfsat_results["anh_sat"],
+                    sulfsat_results["P_sat_anh"],
                     sulfsat_results["DFMQ_anh"],
                     sulfsat_results["fO2_anh"],
                     sulfsat_results["Fe3T_anh"],
@@ -2968,12 +2975,12 @@ def calc_comp_error(setup, run, iterations=100, models=mdv.default_models):
 
     sd[Fe_opt] = setup.loc[run, Fe_opt + "_sd"]
     if Fe_opt + "_sd_type" in setup:
-        sd_type[Fe_opt] = setup.loc[run, Fe_opt + "_sd+type"]
+        sd_type[Fe_opt] = setup.loc[run, Fe_opt + "_sd_type"]
     else:
         sd_type[Fe_opt] = "A"
     sd[fO2_opt] = setup.loc[run, fO2_opt + "_sd"]
     if fO2_opt + "_sd_type" in setup:
-        sd_type[fO2_opt] = setup.loc[run, fO2_opt + "_sd+type"]
+        sd_type[fO2_opt] = setup.loc[run, fO2_opt + "_sd_type"]
     else:
         sd_type[fO2_opt] = "A"
 
@@ -2998,7 +3005,7 @@ def calc_comp_error(setup, run, iterations=100, models=mdv.default_models):
         else:
             sd[x] = ""
         if x + "_sd_type" in setup:
-            sd_type[x] = setup.loc[run, Fe_opt + "_sd+type"]
+            sd_type[x] = setup.loc[run, Fe_opt + "_sd_type"]
         else:
             if x + "_sd" in setup:
                 sd_type[x] = "A"
@@ -3177,46 +3184,81 @@ def calc_comp_error_function(
             return False
 
     if last_row is None:
-        last_row = len(setup) - 1
+        last_row = len(setup)
 
-    for n in range(first_row, last_row, 1):
-        run = n
-        comp = calc_comp_error(setup, run, iterations=iterations, models=models)
-        if function == "calc_Pvsat":
-            result = calc_Pvsat(
-                comp, models=models, first_row=4, last_row=len(comp) - 1
-            )
+    with tqdm.tqdm(total=(last_row - first_row)) as tqdmsteps:
+        for n in range(first_row, last_row, 1):
+            run = n
+            comp = calc_comp_error(setup, run, iterations=iterations, models=models)
+            if function == "calc_Pvsat":
+                result = calc_Pvsat(
+                    comp, models=models, first_row=4, last_row=len(comp) - 1
+                )
 
-        elif function == "calc_melt_S_oxybarometer":
-            result = calc_melt_S_oxybarometer(
-                comp, first_row=4, last_row=len(comp) - 1, models=models
-            )
-        av_results = {}
-        headers = result.columns.tolist()
-        for x in headers:
-            if x == "sample":
-                av_results[x] = setup.loc[run, "Sample"]
-            elif x == "Date":
-                av_results[x] = result.loc[0, x]
-            elif is_number(result.loc[0, x]) is False:
-                if result.loc[0, x] == "False" or result.loc[0, x] == "True":
-                    if "False" in result[x] and "True" in result[x]:
+            elif function == "calc_melt_S_oxybarometer":
+                result = calc_melt_S_oxybarometer(
+                    comp, first_row=4, last_row=len(comp) - 1, models=models
+                )
+            av_results = {}
+            headers = result.columns.tolist()
+            for x in headers:
+                if x == "sample":
+                    av_results[x] = setup.loc[run, "Sample"]
+                elif x == "Date":
+                    av_results[x] = result.loc[0, x]
+                elif x == "sulfide saturated" or x == "anhydrite saturated":
+                    if (
+                        "False" in result[x].tolist()
+                        and "possible" in result[x].tolist()
+                    ):
                         av_results[x] = "Both"
                     else:
                         av_results[x] = result.loc[0, x]
-                else:
+                elif x in [
+                    "P_bar_sulf",
+                    "fO2_DFMQ_sulf",
+                    "fO2_bar_sulf",
+                    "Fe3+/FeT_sulf",
+                    "S6+/ST_sulf",
+                ]:
+                    if av_results["sulfide saturated"] == "False":
+                        av_results[x] = result.loc[0, x]
+                        av_results[x + "_sd"] = ""
+                    else:
+                        if av_results["sulfide saturated"] == "Both":
+                            result[x] = result[x].apply(pd.to_numeric, errors="coerce")
+                        av_results[x] = result[x].mean()
+                        av_results[x + "_sd"] = result[x].std()
+                elif x in [
+                    "P_bar_anh",
+                    "fO2_DFMQ_anh",
+                    "fO2_bar_anh",
+                    "Fe3+/FeT_anh",
+                    "S6+/ST_anh",
+                ]:
+                    if av_results["anhydrite saturated"] == "False":
+                        av_results[x] = result.loc[0, x]
+                        av_results[x + "_sd"] = ""
+                    else:
+                        if av_results["anhydrite saturated"] == "Both":
+                            result[x] = result[x].apply(pd.to_numeric, errors="coerce")
+                        av_results[x] = result[x].mean()
+                        av_results[x + "_sd"] = result[x].std()
+                elif is_number(result.loc[0, x]) is False:
                     av_results[x] = result.loc[0, x]
+                else:
+                    result[x] = result[x].apply(pd.to_numeric, errors="coerce")
+                    av_results[x] = result[x].mean()
+                    av_results[x + "_sd"] = result[x].std()
+                av_results["iterations"] = iterations
+                av_results_all1 = pd.DataFrame(av_results, index=[0])
+            if n == first_row:
+                av_results_all = av_results_all1
             else:
-                av_results[x] = result[x].mean()
-                av_results[x + "_sd"] = result[x].std()
-            av_results["iterations"] = iterations
-            av_results_all1 = pd.DataFrame(av_results, index=[0])
-        if n == first_row:
-            av_results_all = av_results_all1
-        else:
-            av_results_all = pd.concat([av_results_all, av_results_all1])
-        if models.loc["print status", "option"] == "True":
-            print(iterations, setup.loc[run, "Sample"])
+                av_results_all = pd.concat([av_results_all, av_results_all1])
+            if models.loc["print status", "option"] == "True":
+                print(iterations, setup.loc[run, "Sample"])
+            tqdmsteps.update(1)
 
     av_results_all.reset_index(drop=True, inplace=True)
     if models.loc["output csv", "option"] == "True":
@@ -3559,6 +3601,11 @@ def calc_isotopes_gassing(
         else:
             results = pd.concat([results, all_values])
 
+        if models.loc["gassing_style", "option"] == "open":
+            R_i["C"] = R_m_g_C["R_m"]
+            R_i["H"] = R_m_g_H["R_m"]
+            R_i["S"] = R_m_g_S["R_m"]
+
     results.columns = results.iloc[0]
     results = results[1:]
     results.reset_index(drop=True, inplace=True)

{volfe-0.4.1 → volfe-0.4.2}/src/VolFe/calculations.py

@@ -99,7 +99,7 @@ def P_sat(PT, melt_wf, models, Ptol, nr_step, nr_tol):
         difference = abs(guess - mg.p_tot(PT, melt_wf, models))
         return difference
 
-    guess0 = 40000.0  # initial guess for pressure
+    guess0 = 1.0  # initial guess for pressure
     PT["P"] = guess0
     melt_wf1["Fe3FeT"] = mg.Fe3FeT_i(PT, melt_wf1, models)
     melt_wf2["Fe3FeT"] = mg.Fe3FeT_i(PT, melt_wf2, models)
@@ -193,13 +193,15 @@ def P_sat_H2O_CO2(
         }
 
     else:
-        guess0 = 40000.0  # initial guess for pressure
+        guess0 = 1.0  # initial guess for pressure
         PT["P"] = guess0
         delta1 = Pdiff(guess0, melt_wf, models)
         while delta1 > Ptol:
             delta1 = Pdiff(guess0, melt_wf, models)
             guess0 = p_tot_H2O_CO2(PT, melt_wf, models)
             guess0 = float(guess0)
+            # if guess0 > 1.0e7:
+            #    guess0 = 1.0
             PT["P"] = guess0
         else:
             P_sat = guess0
@@ -908,96 +910,74 @@ def P_sat_sulf_anh(PT, melt_wf, models, Ptol, nr_step, nr_tol):
         S62 = S6p / S2m
         S6T = S6p / ST
         if S62 < 0.0:
-            return "not possible", "", "", "", Ssat
+            is_sat = "False"
+            fO2 = ""
+            Fe3T = ""
+            DFMQ = ""
+            S6T = ""
         else:
+            is_sat = "possible"
             fO2 = mg.S6S2_2_fO2(S62, melt_wf, PT, models)
             Fe3T = mdv.fO22Fe3FeT(fO2, PT, melt_wf, models)
             DFMQ = mg.fO22Dbuffer(PT, fO2, "FMQ", models)
-            return Fe3T, fO2, S6T, DFMQ, Ssat
+        return is_sat, Fe3T, fO2, S6T, DFMQ, Ssat
 
-    guess0 = 40000.0  # initial guess for pressure
-    PT["P"] = guess0
+    for phase in ["sulf", "anh"]:
+        guess0 = 1.0  # initial guess for pressure
+        PT["P"] = guess0
+        melt_wf["Fe3FeT"] = 0.1
 
-    # assume it is sulfide saturated
-    melt_wf["Fe3FeT"] = 0.1
-    Fe3T_sulf, fO2_sulf, S6T_sulf, DFMQ_sulf, SCSS_ = S62_2_Fe3T(
-        PT, melt_wf, models, "sulf"
-    )
-    if Fe3T_sulf == "not possible":
-        P_sat_sulf = ""
-        Fe3T_sulf = ""
-        sulfide_sat = "False"
-    else:
-        melt_wf["Fe3FeT"] = Fe3T_sulf
-        ms_conc = eq.melt_speciation(PT, melt_wf, models, nr_step, nr_tol)
-        melt_wf["H2OT"] = ms_conc["wm_H2O"]
-        melt_wf["CO2"] = ms_conc["wm_CO2"]
-        melt_wf["S2-"] = ms_conc["wm_S2m"]
-        melt_wf["ST"] = ST
-        delta1 = Pdiff(guess0, melt_wf, models)
-        while delta1 > Ptol:
-            delta1 = Pdiff(guess0, melt_wf, models)
-            guess0 = mg.p_tot(PT, melt_wf, models)
-            guess0 = float(guess0)
-            PT["P"] = guess0
-            Fe3T_sulf, fO2_sulf, S6T_sulf, DFMQ_sulf, SCSS_ = S62_2_Fe3T(
-                PT, melt_wf, models, "sulf"
-            )
-            if Fe3T_sulf == "not possible":
-                P_sat_sulf = ""
-                Fe3T_sulf = ""
-                sulfide_sat = "False"
-            else:
-                melt_wf["Fe3FeT"] = Fe3T_sulf
-                ms_conc = eq.melt_speciation(PT, melt_wf, models, nr_step, nr_tol)
-                melt_wf["H2OT"] = ms_conc["wm_H2O"]
-                melt_wf["CO2"] = ms_conc["wm_CO2"]
-                melt_wf["S2-"] = ms_conc["wm_S2m"]
+        is_sat, Fe3T, fO2, S6T, DFMQ, Ssat = S62_2_Fe3T(PT, melt_wf, models, phase)
+        if is_sat == "False":
+            P_sat = ""
         else:
-            P_sat_sulf = guess0
-            Fe3T_sulf, fO2_sulf, S6T_sulf, DFMQ_sulf, SCSS_ = S62_2_Fe3T(
-                PT, melt_wf, models, "sulf"
-            )
-            sulfide_sat = "True"
-
-    # assume it is anhydrite saturated
-    Fe3T_anh, fO2_anh, S6T_anh, DFMQ_anh, SCAS_ = S62_2_Fe3T(PT, melt_wf, models, "anh")
-    if Fe3T_anh == "not possible":
-        P_sat_anh = ""
-        Fe3T_anh = ""
-        anhydrite_sat = "False"
-    else:
-        melt_wf["Fe3FeT"] = Fe3T_anh
-        ms_conc = eq.melt_speciation(PT, melt_wf, models, nr_step, nr_tol)
-        melt_wf["H2OT"] = ms_conc["wm_H2O"]
-        melt_wf["CO2"] = ms_conc["wm_CO2"]
-        melt_wf["S2-"] = ms_conc["wm_S2m"]
-        melt_wf["ST"] = ST
-        delta1 = Pdiff(guess0, melt_wf, models)
-        while delta1 > Ptol:
+            melt_wf["Fe3FeT"] = Fe3T
+            ms_conc = eq.melt_speciation(PT, melt_wf, models, nr_step, nr_tol)
+            melt_wf["H2OT"] = ms_conc["wm_H2O"]
+            melt_wf["CO2"] = ms_conc["wm_CO2"]
+            melt_wf["S2-"] = ms_conc["wm_S2m"]
+            melt_wf["ST"] = ST
             delta1 = Pdiff(guess0, melt_wf, models)
-            guess0 = mg.p_tot(PT, melt_wf, models)
-            guess0 = float(guess0)
-            PT["P"] = guess0
-            Fe3T_anh, fO2_anh, S6T_anh, DFMQ_anh, SCAS_ = S62_2_Fe3T(
-                PT, melt_wf, models, "anh"
-            )
-            if Fe3T_anh == "not possible":
-                P_sat_anh = ""
-                Fe3T_anh = ""
-                anhydrite_sat = "False"
+            while delta1 > Ptol:
+                delta1 = Pdiff(guess0, melt_wf, models)
+                guess0 = mg.p_tot(PT, melt_wf, models)
+                guess0 = float(guess0)
+                PT["P"] = guess0
+                is_sat, Fe3T, fO2, S6T, DFMQ, Ssat = S62_2_Fe3T(
+                    PT, melt_wf, models, phase
+                )
+                if is_sat == "False":
+                    P_sat = ""
+                else:
+                    melt_wf["Fe3FeT"] = Fe3T
+                    ms_conc = eq.melt_speciation(PT, melt_wf, models, nr_step, nr_tol)
+                    melt_wf["H2OT"] = ms_conc["wm_H2O"]
+                    melt_wf["CO2"] = ms_conc["wm_CO2"]
+                    melt_wf["S2-"] = ms_conc["wm_S2m"]
             else:
-                melt_wf["Fe3FeT"] = Fe3T_anh
-                ms_conc = eq.melt_speciation(PT, melt_wf, models, nr_step, nr_tol)
-                melt_wf["H2OT"] = ms_conc["wm_H2O"]
-                melt_wf["CO2"] = ms_conc["wm_CO2"]
-                melt_wf["S2-"] = ms_conc["wm_S2m"]
-        else:
-            P_sat_anh = guess0
-            Fe3T_anh, fO2_anh, S6T_anh, DFMQ_anh, SCAS_ = S62_2_Fe3T(
-                PT, melt_wf, models, "anh"
-            )
-            anhydrite_sat = "True"
+                if is_sat == "False":
+                    P_sat = ""
+                else:
+                    P_sat = guess0
+                    is_sat, Fe3T, fO2, S6T, DFMQ, Ssat = S62_2_Fe3T(
+                        PT, melt_wf, models, phase
+                    )
+        if phase == "sulf":
+            P_sat_sulf = P_sat
+            SCSS_ = Ssat
+            sulfide_sat = is_sat
+            DFMQ_sulf = DFMQ
+            Fe3T_sulf = Fe3T
+            fO2_sulf = fO2
+            S6T_sulf = S6T
+        elif phase == "anh":
+            P_sat_anh = P_sat
+            SCAS_ = Ssat
+            anhydrite_sat = is_sat
+            DFMQ_anh = DFMQ
+            Fe3T_anh = Fe3T
+            fO2_anh = fO2
+            S6T_anh = S6T
 
     result = {
         "P_sat_sulf": P_sat_sulf,
@@ -1563,9 +1543,7 @@ def conc_insolubles(PT, melt_wf, models):
     S2m = melt_wf["S2-"]  # weight fraction of S2-
     S6p = (
         mg.C_SO4(PT, melt_wf, models) * mdv.f_O2(PT, melt_wf, models) ** 2 * S2m
-    ) / mg.C_S(
-        PT, melt_wf, models
-    )  # weight fraction S6+
+    ) / mg.C_S(PT, melt_wf, models)  # weight fraction S6+
     H2S = (
         mg.C_H2S(PT, melt_wf, models) * mg.f_H2S(PT, melt_wf, models)
     ) / 1000000.0  # weight fraction H2S
@@ -1658,9 +1636,27 @@ def compositions_within_error(run, setup):
             if x + "_sd_type" in setup:
                 if setup.loc[run, x + "_sd_type"] == "R":  # relative
                     sd = setup.loc[run, x + "_sd"] * setup.loc[run, x]
-            else:
+                else:
+                    sd = setup.loc[run, x + "_sd"]
+            elif x + "_sd" in setup:
                 sd = setup.loc[run, x + "_sd"]
+            else:
+                sd = 0.0
             value = float(np.random.normal(setup.loc[run, x], sd, 1))
+
+            if x in ["Fe3FeT", "S6ST"]:
+                if value < 0.001:
+                    value = 0.001
+                if value > 0.999:
+                    value = 0.999
+            if (x != "DFMQ") is True and (x != "DNNO") is True:
+                if value < 0.0:
+                    value = 0.0
+            if x == "STppm":
+                if value == 0.0:
+                    if "S6ST" in setup:
+                        value = 1.0
+
             result[x] = value
         else:
             result[x] = 0.0