DiadFit 0.0.84__py3-none-any.whl → 0.0.88__py3-none-any.whl

DiadFit/CO2_in_bubble_error.py

@@ -2,9 +2,24 @@ import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 
+# Lets use a generic function for getting a panda series value or not.
 
-def propagate_CO2_in_bubble(*, N_dup=1000, sample_ID, vol_perc_bub, melt_dens_kgm3, CO2_bub_dens_gcm3,
-error_vol_perc_bub=0, error_type_vol_perc_bub='Abs', error_dist_vol_perc_bub='normal',
+def get_value(variable, i):
+    """ This function returns the value if its not a series, otherwise returns the right row in the series
+    """
+    if isinstance(variable, pd.Series):
+        return variable.iloc[i]
+    else:
+        return variable
+
+const=(4/3)*np.pi
+
+def propagate_CO2_in_bubble(*, N_dup=1000, sample_ID, vol_perc_bub=None, error_vol_perc_bub=None, error_type_vol_perc_bub='Abs',
+MI_x=None, MI_y=None,MI_z=None,VB_x=None, VB_y=None,VB_z=None,
+error_MI_x=None, error_MI_y=None,error_MI_z=None,error_VB_x=None, error_VB_y=None, error_VB_z=None,
+error_type_dimension='Abs', error_dist_dimension='normal',
+melt_dens_kgm3, CO2_bub_dens_gcm3,
+ error_dist_vol_perc_bub='normal',
 error_CO2_bub_dens_gcm3=0, error_type_CO2_bub_dens_gcm3='Abs', error_dist_CO2_bub_dens_gcm3='normal',
 error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kgm3='normal',
 plot_figure=True, fig_i=0, neg_values=True):
@@ -23,9 +38,32 @@ plot_figure=True, fig_i=0, neg_values=True):
     N_dup: int
         Number of duplicates when generating errors for Monte Carlo simulations
 
+    Now, either you know the vol% of the bubble and the associated error, in which case enter these two arguements:
+
     vol_perc_bub: int, float, pd.series
         Volume proportion of sulfide in melt inclusion
 
+    error_vol_perc_bub, CO2_bub_dens_gcm3, error_melt_dens_kgm3: int, float, pd.Series
+        Error for each variable, can be absolute or %
+
+    error_type_vol_perc_bub, error_type_bub_dens_gcm3, error_type_melt_dens_kgm3: 'Abs' or 'Perc'
+        whether given error is perc or absolute
+
+    Or, you have measured the x-y-z dimensions of the MI and VB (e.g. by perpendicular polishing).
+
+    MI_x, MI_y, MI_Z, VB_x, VB_y, VB_Z: int, float, pd.Series
+        x, y, z dimensions of vapour bubble and melt inclusion
+
+    error_MI_x, error_MI_y, error_MI_Z, error_VB_x, error_VB_y, error_VB_Z: int, float, pd.Series
+        Error on x, y, z dimension meausurement
+
+    error_type_dimension: 'Abs' or 'Perc'
+        Whether errors on all x-y-z are perc or abs
+
+    error_dist_dimension: 'normal' or 'uniform'
+        Whether errors on all x-y-z are normally or uniformly distributed.
+
+
     melt_dens_kgm3:int, float, pd.series
         Density of the silicate melt in kg/m3, e.g. from DensityX
 
@@ -33,13 +71,7 @@ plot_figure=True, fig_i=0, neg_values=True):
         Density of the vapour bubble in g/cm3
 
 
-    error_vol_perc_bub, CO2_bub_dens_gcm3, error_melt_dens_kgm3: int, float, pd.Series
-        Error for each variable, can be absolute or %
-
-    error_type_vol_perc_bub, error_type_bub_dens_gcm3, error_type_melt_dens_kgm3: 'Abs' or 'Perc'
-        whether given error is perc or absolute
-
-    error_dist_vol_perc_bub, error_dist_bub_dens_gcm3, error_dist_melt_dens_kgm3: 'normal' or 'uniform'
+    error_dist_vol_perc_bub, error_dist_bub_dens_gcm3, error_dist_melt_dens_kgm3, error_dist_dimension: 'normal' or 'uniform'
         Distribution of simulated error
 
     plot_figure: bool
@@ -56,30 +88,46 @@ plot_figure=True, fig_i=0, neg_values=True):
         df_step has average and standard deviation for each sample
 
     """
+    # Constant for sphere calcs
+
+     # Lets check what they entered for volume - if they didnt enter a volume % Bubble, lets calculate it
+    if vol_perc_bub is None:
+        Vol_VB_sphere=const*VB_x*VB_y*VB_z
+        Vol_MI_sphere=const*MI_x*MI_y*MI_z
+        vol_perc_bub=100* Vol_VB_sphere/Vol_MI_sphere
+
+    # Now lets check how they entered error in volume
+    if not ((error_vol_perc_bub is not None and all(v is None for v in [error_MI_x, error_MI_y, error_MI_z, error_VB_x, error_VB_y, error_VB_z])) or (error_vol_perc_bub is None and all(v is not None for v in [error_MI_x, error_MI_y, error_MI_z, error_VB_x, error_VB_y, error_VB_z]))):
+            raise ValueError('Specify either error_vol_perc_bub or non-None values for all of error_MI_x, error_MI_y, error_MI_z, error_VB_x, error_VB_y, and error_VB_z.')
 
 
 
-    # Set up empty things to fill up.
 
+    # Set up empty things to fill up.
     if type(vol_perc_bub) is pd.Series:
         len_loop=len(vol_perc_bub)
+
     else:
         len_loop=1
 
 
 
-    mean_CO2_eq_melt = np.empty(len_loop, dtype=float)
-    mean_CO2_eq_melt_ind = np.empty(len_loop, dtype=float)
-    med_CO2_eq_melt  = np.empty(len_loop, dtype=float)
-    std_CO2_eq_melt  = np.empty(len_loop, dtype=float)
-    preferred_val_CO2_melt= np.empty(len_loop, dtype=float)
-    std_IQR_CO2_eq_melt= np.empty(len_loop, dtype=float)
-    Sample=np.empty(len_loop,  dtype=np.dtype('U100') )
+    mean_CO2_eq_melt = np.zeros(len_loop, dtype=float)
+    mean_CO2_eq_melt_ind = np.zeros(len_loop, dtype=float)
+    med_CO2_eq_melt  = np.zeros(len_loop, dtype=float)
+    std_CO2_eq_melt  = np.zeros(len_loop, dtype=float)
+    preferred_val_CO2_melt= np.zeros(len_loop, dtype=float)
+    std_IQR_CO2_eq_melt= np.zeros(len_loop, dtype=float)
+    Q84= np.zeros(len_loop, dtype=float)
+    Q16= np.zeros(len_loop, dtype=float)
+    Sample=np.zeros(len_loop,  dtype=np.dtype('U100') )
 
 
     All_outputs=pd.DataFrame([])
 
 
+
+
     #This loops through each sample
     for i in range(0, len_loop):
         if i % 20 == 0:
@@ -89,67 +137,76 @@ plot_figure=True, fig_i=0, neg_values=True):
         # If user has entered a pandas series for error, takes right one for each loop
         # vol_perc_bub % and error
 
-        # Checking volume right format
-        if type(vol_perc_bub) is pd.Series:
-            vol_perc_bub_i=vol_perc_bub.iloc[i]
-        else:
-            vol_perc_bub_i=vol_perc_bub
+        # Checking volume right format, if panda series or integer
+        vol_perc_bub_i=get_value(vol_perc_bub, i)
+        error_vol_perc_bub_i=get_value(error_vol_perc_bub, i)
 
+        CO2_bub_dens_gcm3_i=get_value(CO2_bub_dens_gcm3, i)
+        error_CO2_bub_dens_gcm3_i=get_value(error_CO2_bub_dens_gcm3, i)
 
-        if type(error_vol_perc_bub) is pd.Series:
-            error_vol_perc_bub_i=error_vol_perc_bub.iloc[i]
-        else:
-            error_vol_perc_bub_i=error_vol_perc_bub
+        melt_dens_kgm3_i=get_value(melt_dens_kgm3, i)
+        error_melt_dens_kgm3_i=get_value(error_melt_dens_kgm3, i)
 
-        # Checking bubble dens right form
 
-        if type(CO2_bub_dens_gcm3) is pd.Series:
-            CO2_bub_dens_gcm3_i=CO2_bub_dens_gcm3.iloc[i]
-        else:
-            CO2_bub_dens_gcm3_i=CO2_bub_dens_gcm3
 
-        # Checking melt density
-
-        if type(error_CO2_bub_dens_gcm3) is pd.Series:
-            error_CO2_bub_dens_gcm3_i=error_CO2_bub_dens_gcm3.iloc[i]
-        else:
-            error_CO2_bub_dens_gcm3_i=error_CO2_bub_dens_gcm3
-
-        # Checking melt density
 
+        # This is the function doing the work to actually make the simulations for each variable.
+        if error_vol_perc_bub is not None:
+
+            df_synthetic=propagate_CO2_in_bubble_ind(
+    N_dup=N_dup,
+    vol_perc_bub=vol_perc_bub_i,
+    melt_dens_kgm3=melt_dens_kgm3_i,
+    CO2_bub_dens_gcm3=CO2_bub_dens_gcm3_i,
+    error_CO2_bub_dens_gcm3=error_CO2_bub_dens_gcm3_i,
+    error_type_CO2_bub_dens_gcm3=error_type_CO2_bub_dens_gcm3,
+    error_dist_CO2_bub_dens_gcm3=error_dist_CO2_bub_dens_gcm3,
+    error_vol_perc_bub=error_vol_perc_bub_i,
+    error_type_vol_perc_bub=error_type_vol_perc_bub,
+    error_dist_vol_perc_bub=error_dist_vol_perc_bub,
+    error_melt_dens_kgm3=error_melt_dens_kgm3_i,
+    error_type_melt_dens_kgm3=error_type_melt_dens_kgm3,
+    error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
+    len_loop=1, neg_values=neg_values)
 
-        if type(melt_dens_kgm3) is pd.Series:
-            melt_dens_kgm3_i=melt_dens_kgm3.iloc[i]
         else:
-            melt_dens_kgm3_i=melt_dens_kgm3
 
+            # This is the more complex one where we have to account for x-y-z errors on all of them.
+            MI_x_i = get_value(MI_x, i)
+            MI_y_i = get_value(MI_y, i)
+            MI_z_i = get_value(MI_z, i)
+            VB_x_i = get_value(VB_x, i)
+            VB_y_i = get_value(VB_y, i)
+            VB_z_i = get_value(VB_z, i)
 
-        if type(error_melt_dens_kgm3) is pd.Series:
-            error_melt_dens_kgm3_i=error_melt_dens_kgm3.iloc[i]
-        else:
-            error_melt_dens_kgm3_i=error_melt_dens_kgm3
-
+            error_MI_x_i = get_value(error_MI_x, i)
+            error_MI_y_i = get_value(error_MI_y, i)
+            error_MI_z_i = get_value(error_MI_z, i)
+            error_VB_x_i = get_value(error_VB_x, i)
+            error_VB_y_i = get_value(error_VB_y, i)
+            error_VB_z_i = get_value(error_VB_z, i)
 
 
 
+            df_synthetic=propagate_CO2_in_bubble_ind(
+    N_dup=N_dup,
+    vol_perc_bub=vol_perc_bub_i,
+    melt_dens_kgm3=melt_dens_kgm3_i,
+    CO2_bub_dens_gcm3=CO2_bub_dens_gcm3_i,
+    error_CO2_bub_dens_gcm3=error_CO2_bub_dens_gcm3_i,
+    error_type_CO2_bub_dens_gcm3=error_type_CO2_bub_dens_gcm3,
+    error_dist_CO2_bub_dens_gcm3=error_dist_CO2_bub_dens_gcm3,
+    error_vol_perc_bub=None,
+MI_x=MI_x_i, MI_y=MI_y_i,MI_z=MI_z_i,VB_x=VB_x_i, VB_y=VB_y_i,VB_z=VB_z_i,
+error_MI_x=error_MI_x_i, error_MI_y=error_MI_y_i,error_MI_z=error_MI_z_i,
+error_VB_x=error_VB_x_i, error_VB_y=error_VB_y_i, error_VB_z=error_VB_z_i,
+error_type_dimension=error_type_dimension, error_dist_dimension=error_dist_dimension,
+    error_melt_dens_kgm3=error_melt_dens_kgm3_i,
+    error_type_melt_dens_kgm3=error_type_melt_dens_kgm3,
+    error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
+    len_loop=1, neg_values=neg_values)
 
 
-        # This is the function doing the work to actually make the simulations for each variable.
-        df_synthetic=propagate_CO2_in_bubble_ind(
-N_dup=N_dup,
-vol_perc_bub=vol_perc_bub_i,
-melt_dens_kgm3=melt_dens_kgm3_i,
-CO2_bub_dens_gcm3=CO2_bub_dens_gcm3_i,
-error_CO2_bub_dens_gcm3=error_CO2_bub_dens_gcm3_i,
-error_type_CO2_bub_dens_gcm3=error_type_CO2_bub_dens_gcm3,
- error_dist_CO2_bub_dens_gcm3=error_dist_CO2_bub_dens_gcm3,
-error_vol_perc_bub=error_vol_perc_bub_i,
-error_type_vol_perc_bub=error_type_vol_perc_bub,
-error_dist_vol_perc_bub=error_dist_vol_perc_bub,
-error_melt_dens_kgm3=error_melt_dens_kgm3_i,
-error_type_melt_dens_kgm3=error_type_melt_dens_kgm3,
-error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
- len_loop=1, neg_values=neg_values)
 
 
         # Convert to densities for MC
@@ -186,12 +243,16 @@ error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
         med_CO2_eq_melt[i]=np.nanmedian(df['CO2_eq_melt_ppm_MC'])
         std_CO2_eq_melt[i]=np.nanstd(df['CO2_eq_melt_ppm_MC'])
         var=df['CO2_eq_melt_ppm_MC']
+        Q16[i]=np.percentile(var, 16)
+        Q84[i]=np.percentile(var, 84)
         std_IQR_CO2_eq_melt[i]=0.5*np.abs((np.percentile(var, 84) -np.percentile(var, 16)))
 
-        preferred_val_CO2_melt[i]=np.nanmean(df['CO2_eq_melt_ppm_noMC'])
 
 
-        mean_CO2_eq_melt_ind[i]=df['CO2_eq_melt_ppm_noMC'].iloc[0]
+        # Values all the same, so can just take the 1st.
+        preferred_val_CO2_melt[i]=df['CO2_eq_melt_ppm_noMC'].iloc[0]
+
+
 
 
 
@@ -202,7 +263,9 @@ error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
                         'CO2_eq_in_melt_noMC': preferred_val_CO2_melt,
                         'mean_MC_CO2_equiv_melt_ppm': mean_CO2_eq_melt,
                         'med_MC_CO2_equiv_melt_ppm': med_CO2_eq_melt,
-                        'std_MC_CO2_equiv_melt_ppm': std_IQR_CO2_eq_melt,
+                        'std_MC_IQR_CO2_equiv_melt_ppm': std_IQR_CO2_eq_melt,
+                        '16th_quantile_melt_ppm': Q16,
+                        '84th_quantile_melt_ppm': Q84,
 
 
 
@@ -238,12 +301,43 @@ error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
 
 
 
+def add_noise_to_variable(original_value, error, error_type, error_dist, N_dup, neg_values, neg_threshold):
+        """ This function adds noise to each variable for the monte-carloing
+
+        """
+
+        #  Depending on the error type, allocates an error
+        if error_type == 'Abs':
+            calculated_error = error
+        elif error_type == 'Perc':
+            calculated_error = original_value * error / 100
+
+        # Generates noise following a distribution
+        if error_dist == 'normal':
+            noise_to_add = np.random.normal(0, calculated_error, N_dup)
+        elif error_dist == 'uniform':
+            noise_to_add = np.random.uniform(-calculated_error, calculated_error, N_dup)
+
+        # adds this noise to original value
+        value_with_noise = noise_to_add + original_value
+
+        if not neg_values:
+            value_with_noise[value_with_noise < neg_threshold] = neg_threshold
+
+        return value_with_noise
+
+
+
+
 
 
 
 def propagate_CO2_in_bubble_ind(sample_i=0,  N_dup=1000, vol_perc_bub=None,
 CO2_bub_dens_gcm3=None, melt_dens_kgm3=None,
-error_vol_perc_bub=0, error_type_vol_perc_bub='Abs', error_dist_vol_perc_bub='normal',
+MI_x=None, MI_y=None,MI_z=None,VB_x=None, VB_y=None,VB_z=None,
+error_MI_x=None, error_MI_y=None,error_MI_z=None,error_VB_x=None, error_VB_y=None, error_VB_z=None,
+error_type_dimension='Abs', error_dist_dimension='normal',
+error_vol_perc_bub=None, error_type_vol_perc_bub='Abs', error_dist_vol_perc_bub='normal',
 error_CO2_bub_dens_gcm3=0, error_type_CO2_bub_dens_gcm3='Abs', error_dist_CO2_bub_dens_gcm3='normal',
 error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kgm3='normal', len_loop=1, neg_values=True):
 
@@ -300,7 +394,7 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
 
     """
 
-
+    # If only a single sample, set up an output dataframe with an index.
     if len_loop==1:
         df_c=pd.DataFrame(data={
                             'vol_perc_bub': vol_perc_bub,
@@ -316,64 +410,56 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
 
 
 
-    # Volume error distribution
+    # Volume error distribution - if they give a volume percentage rather than dimensions
+    if error_vol_perc_bub is not None:
+        # Easy peasy
+        Vol_with_noise=add_noise_to_variable(vol_perc_bub, error_vol_perc_bub,
+        error_type_vol_perc_bub, error_dist_vol_perc_bub,  N_dup, neg_values, neg_threshold=0.0000000001)
+
+    else:
+        x_MI_with_noise=add_noise_to_variable(MI_x, error_MI_x,
+        error_type_dimension, error_dist_dimension, N_dup, neg_values, neg_threshold=0.0000000001)
+
+        y_MI_with_noise=add_noise_to_variable(MI_y, error_MI_y,
+        error_type_dimension, error_dist_dimension, N_dup, neg_values, neg_threshold=0.0000000001)
+
+        z_MI_with_noise=add_noise_to_variable(MI_z, error_MI_z,
+        error_type_dimension, error_dist_dimension, N_dup, neg_values, neg_threshold=0.0000000001)
 
-    if error_type_vol_perc_bub=='Abs':
-        error_Vol=error_vol_perc_bub
-    if error_type_vol_perc_bub =='Perc':
-        error_Vol=df_c['vol_perc_bub'].iloc[sample_i]*error_vol_perc_bub/100
-    if error_dist_vol_perc_bub=='normal':
-        Noise_to_add_Vol = np.random.normal(0, error_Vol, N_dup)
-    if error_dist_vol_perc_bub=='uniform':
-        Noise_to_add_Vol = np.random.uniform(- error_Vol, +
-                                                      error_Vol, N_dup)
+        x_VB_with_noise=add_noise_to_variable(VB_x, error_VB_x,
+        error_type_dimension, error_dist_dimension,  N_dup, neg_values, neg_threshold=0.0000000001)
 
-    Vol_with_noise=Noise_to_add_Vol+df_c['vol_perc_bub'].iloc[sample_i]
-    if neg_values is False:
-        Vol_with_noise[Vol_with_noise < 0.000000000000001] = 0.000000000000001
+        y_VB_with_noise=add_noise_to_variable(VB_y, error_VB_y,
+        error_type_dimension, error_dist_dimension, N_dup, neg_values, neg_threshold=0.0000000001)
 
-    #
+        z_VB_with_noise=add_noise_to_variable(VB_z, error_VB_z,
+        error_type_dimension, error_dist_dimension, N_dup, neg_values, neg_threshold=0.0000000001)
 
-    # Volume error distribution
 
-    if error_type_CO2_bub_dens_gcm3=='Abs':
-        error_CO2_bub_dens_gcm3=error_CO2_bub_dens_gcm3
-    if error_type_CO2_bub_dens_gcm3 =='Perc':
-        error_CO2_bub_dens_gcm3=df_c['vol_perc_bub'].iloc[sample_i]*error_CO2_bub_dens_gcm3/100
-    if error_dist_CO2_bub_dens_gcm3=='normal':
-        Noise_to_add_CO2_bub_dens_gcm3 = np.random.normal(0, error_CO2_bub_dens_gcm3, N_dup)
-    if error_dist_CO2_bub_dens_gcm3=='uniform':
-        Noise_to_add_CO2_bub_dens_gcm3 = np.random.uniform(- error_CO2_bub_dens_gcm3, +
-                                                      error_CO2_bub_dens_gcm3, N_dup)
+        Vol_VB_sphere_with_noise=const*x_VB_with_noise*y_VB_with_noise*z_VB_with_noise
+        Vol_MI_sphere_with_noise=const*x_MI_with_noise*y_MI_with_noise*z_MI_with_noise
+        Vol_with_noise=100* Vol_VB_sphere_with_noise/Vol_MI_sphere_with_noise
 
-    CO2_bub_dens_gcm3_with_noise=Noise_to_add_CO2_bub_dens_gcm3+df_c['CO2_bub_dens_gcm3'].iloc[sample_i]
-    if neg_values is False:
-        CO2_bub_dens_gcm3_with_noise[CO2_bub_dens_gcm3_with_noise < 0.000000000000001] = 0.000000000000001
 
-    # Volume error distribution
+    # Bubble density
+    CO2_bub_dens_gcm3_with_noise=add_noise_to_variable(CO2_bub_dens_gcm3, error_CO2_bub_dens_gcm3,
+        error_type_CO2_bub_dens_gcm3, error_dist_CO2_bub_dens_gcm3, N_dup, neg_values, neg_threshold=0.0000000001)
 
-    if error_type_melt_dens_kgm3=='Abs':
-        error_melt_dens_kgm3=error_melt_dens_kgm3
-    if error_type_melt_dens_kgm3 =='Perc':
-        error_melt_dens_kgm3=df_c['vol_perc_bub'].iloc[sample_i]*error_melt_dens_kgm3/100
-    if error_dist_melt_dens_kgm3=='normal':
-        Noise_to_add_melt_dens_kgm3 = np.random.normal(0, error_melt_dens_kgm3, N_dup)
-    if error_dist_melt_dens_kgm3=='uniform':
-        Noise_to_add_melt_dens_kgm3 = np.random.uniform(- error_melt_dens_kgm3, +
-                                                      error_melt_dens_kgm3, N_dup)
+    # Melt density
+    melt_dens_kgm3_with_noise=add_noise_to_variable(melt_dens_kgm3, error_melt_dens_kgm3,
+        error_type_melt_dens_kgm3, error_dist_melt_dens_kgm3,  N_dup, neg_values, neg_threshold=0.0000000001)
 
-    melt_dens_kgm3_with_noise=Noise_to_add_melt_dens_kgm3+df_c['melt_dens_kgm3'].iloc[sample_i]
-    if neg_values is False:
-        melt_dens_kgm3_with_noise[melt_dens_kgm3_with_noise < 0.000000000000001] = 0.000000000000001
+    # Now lets calculate the equilibrium CO2 content of the melt
     CO2_eq_melt_ind=10**4 * (df_c['vol_perc_bub']*df_c['CO2_bub_dens_gcm3'])/(df_c['melt_dens_kgm3']/1000)
-    df_out=pd.DataFrame(data={
+
+    if error_vol_perc_bub is not None:
+        df_out=pd.DataFrame(data={
 
                                 'vol_perc_bub_with_noise': Vol_with_noise,
                                 'CO2_bub_dens_gcm3_with_noise': CO2_bub_dens_gcm3_with_noise,
                                 'melt_dens_kgm3_with_noise': melt_dens_kgm3_with_noise,
                                 'vol_perc_bub': df_c['vol_perc_bub'].iloc[sample_i],
                                 'CO2_bub_dens_gcm3': CO2_bub_dens_gcm3,
-                                'Absolute_error_Vol': error_Vol,
                                 'error_type_vol_perc_bub': error_type_vol_perc_bub,
                                 'error_dist_Vol': error_dist_vol_perc_bub,
                                 'error_CO2_bub_dens_gcm3': error_CO2_bub_dens_gcm3,
@@ -381,6 +467,27 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
                                 'error_dist_CO2_bub_dens_gcm3': error_dist_CO2_bub_dens_gcm3,
                                 })
 
+    else:
+        df_out=pd.DataFrame(data={
+
+                                'vol_perc_bub_with_noise': Vol_with_noise,
+                                'CO2_bub_dens_gcm3_with_noise': CO2_bub_dens_gcm3_with_noise,
+                                'melt_dens_kgm3_with_noise': melt_dens_kgm3_with_noise,
+                                'vol_perc_bub': df_c['vol_perc_bub'].iloc[sample_i],
+                                'CO2_bub_dens_gcm3': CO2_bub_dens_gcm3,
+                                'error_CO2_bub_dens_gcm3': error_CO2_bub_dens_gcm3,
+                                'error_type_CO2_bub_dens_gcm3': error_type_CO2_bub_dens_gcm3,
+                                'error_dist_CO2_bub_dens_gcm3': error_dist_CO2_bub_dens_gcm3,
+                                'Vol_VB_with_noise': Vol_VB_sphere_with_noise,
+                                'Vol_MI_with_noise': Vol_MI_sphere_with_noise,
+                                'VB_x_with_noise': x_VB_with_noise,
+                                'VB_y_with_noise':y_VB_with_noise,
+                                'VB_z_with_noise': z_VB_with_noise,
+                                'MI_x_with_noise': x_MI_with_noise,
+                                'MI_y_with_noise': y_MI_with_noise,
+                                'MI_z_with_noise': z_MI_with_noise,
+                                })
+
     CO2_eq_melt=10**4*((df_out['vol_perc_bub_with_noise']*df_out['CO2_bub_dens_gcm3_with_noise']))/(df_out['melt_dens_kgm3_with_noise']/1000)
 
     df_out.insert(0, 'CO2_eq_melt_ppm_MC',CO2_eq_melt)
@@ -388,10 +495,5 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
     df_out.insert(1, 'CO2_eq_melt_ppm_noMC',float(CO2_eq_melt_ind.values))
 
 
-
-
-
-
-
     return df_out
 

DiadFit/_version.py

@@ -5,4 +5,4 @@
 # 1) we don't load dependencies by storing it in __init__.py
 # 2) we can import it in setup.py for the same reason
 # 3) we can import it into your module
-__version__ = '0.0.84'
+__version__ = '0.0.88'

DiadFit/densimeter_fitting.py

@@ -113,7 +113,7 @@ def plot_and_save_CO2cali_pickle(*, cali_data, CO2_dens_col='rho',Split_col='Spl
         Whether to save the plot as an image (default: False).
 
     eq_division (str, optional):
-        Method for dividing the data based on density ('ccmr' or 'cmass', default: 'ccmr'). CCMR corresponds to the limits for each section as shown in DeVitre et al., 2021 (Chem. Geo), cmass is for those in DeVitre et al., 2023 (J. Volcanica)
+        Method for dividing the data based on density ('ccmr', 'cmass', or 'cmass_24C', default: 'ccmr'). CCMR corresponds to the limits for each section as shown in DeVitre et al., 2021 (Chem. Geo), cmass is for those in DeVitre et al., 2023 (J. Volcanica).
 
     save_suffix (str, optional):
         Suffix to be added to the saved file names (default: '').
@@ -134,6 +134,12 @@ def plot_and_save_CO2cali_pickle(*, cali_data, CO2_dens_col='rho',Split_col='Spl
             midcut_low=0.13
             midcut_high=0.70
             highcut=0.65
+
+        elif eq_division=='cmass_24C':
+            lowcut=0.24
+            midcut_low=0.24
+            midcut_high=0.65
+            highcut=0.65
         if density_range == 'Low':
             cali_data = cali_data[cali_data[CO2_dens_col] < lowcut]