DiadFit 0.0.90__py3-none-any.whl → 1.0.1__py3-none-any.whl

DiadFit/CO2_in_bubble_error.py

@@ -90,10 +90,16 @@ plot_figure=True, fig_i=0, neg_values=True):
     """
     # 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
+        if VB_z is None:
+            VB_z=(VB_x+VB_y)/2
+        if MI_z is None:
+            MI_z=(MI_x+MI_y)/2
+
+        Vol_VB_sphere=const*VB_x*VB_y*VB_z*(0.5)**3
+        Vol_MI_sphere=const*MI_x*MI_y*MI_z*(0.5)**3
         vol_perc_bub=100* Vol_VB_sphere/Vol_MI_sphere
 
     # Now lets check how they entered error in volume
@@ -128,6 +134,7 @@ plot_figure=True, fig_i=0, neg_values=True):
 
 
 
+
     #This loops through each sample
     for i in range(0, len_loop):
         if i % 20 == 0:
@@ -153,6 +160,7 @@ plot_figure=True, fig_i=0, neg_values=True):
         # 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,
@@ -169,15 +177,27 @@ plot_figure=True, fig_i=0, neg_values=True):
     error_dist_melt_dens_kgm3=error_dist_melt_dens_kgm3,
     len_loop=1, neg_values=neg_values)
 
+
+
         else:
 
+
             # 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)
+            MI_z_i = get_value(MI_z, i)
+
+
 
             error_MI_x_i = get_value(error_MI_x, i)
             error_MI_y_i = get_value(error_MI_y, i)
@@ -299,11 +319,33 @@ error_type_dimension=error_type_dimension, error_dist_dimension=error_dist_dimen
 
     return df_step, All_outputs, fig if 'fig' in locals() else None
 
-
+# Lets set the random seed
+np.random.seed(42)
 
 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
 
+        Parameters
+        -----------------
+        original_value: int, float
+            Preferred value (e.g. center of distribution)
+
+        error: int, float
+            Error value
+
+        error_type: str
+            'Abs' if absolute error, 'Perc' if percent
+
+        error_dist: str
+            'normal' if normally distributed, 'uniform' if uniformly distributed.
+
+        N_dup: int
+            number of duplicates
+
+        neg_values: bool
+            whether negative values are replaced with zeros
+
+
         """
 
         #  Depending on the error type, allocates an error
@@ -351,14 +393,47 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
 
     Parameters
     ----------------
+    For volumes, either enter vol% bubble and associated errors...
+
+    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
+
+    error_dist_vol_perc_bub, error_dist_bub_dens_gcm3, error_dist_melt_dens_kgm3: 'normal' or 'uniform'
+        Distribution of simulated error
+
+
+    OR
+    Enter melt inclusion and vapour bubble dimensions (diameter, not radii), and their errors
+    MI_x, MI_y, MI_z, VB_x, VB_y, VB_z: int, float, series:
+        Diameter of melt inclusions.
+
+    error_MI_x, error_MI_y, error_MI_z, error_VB_x, error_VB_y, error_VB_z:
+        Error on diameter of melt inclusions
+
+    error_type_dimension='Abs' or 'Perc':
+        Specify whether errors on these dimensions are absolute or percentage
+
+    error_dist_dimension='normal' or 'uniform':
+        Specify error distribution
+
+
+
+
+
     SampleID: str, pd.series
         Sample_ID (e.g. sample names) which is returned on dataframe
 
     N_dup: int
         Number of duplicates when generating errors for Monte Carlo simulations
 
-    vol_perc_bub: int, float, pd.series
-        Volume proportion of sulfide in melt inclusion
+
 
     melt_dens_kgm3:int, float, pd.series
         Density of the silicate melt in kg/m3, e.g. from DensityX
@@ -367,14 +442,6 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
         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'
-        Distribution of simulated error
 
     plot_figure: bool
         Default true - plots a figure of the row indicated by fig_i (default 1st row, fig_i=0)
@@ -412,32 +479,37 @@ error_melt_dens_kgm3=0, error_type_melt_dens_kgm3='Abs', error_dist_melt_dens_kg
 
     # Volume error distribution - if they give a volume percentage rather than dimensions
     if error_vol_perc_bub is not None:
+        print('using error on the bubble volume percent, not the entered dimensions, as error_vol_perc_bub was 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)
-
         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)
 
         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_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)
+
+
         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)
 
 
-        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_VB_sphere_with_noise=const*x_VB_with_noise*y_VB_with_noise*z_VB_with_noise*(0.5)**3
+        Vol_MI_sphere_with_noise=const*x_MI_with_noise*y_MI_with_noise*z_MI_with_noise*(0.5)**3
         Vol_with_noise=100* Vol_VB_sphere_with_noise/Vol_MI_sphere_with_noise
 
 

DiadFit/H2O_fitting.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from typing import Tuple, Optional
 from DiadFit.importing_data_files import *
 from numpy import trapz
-from scipy.integrate import simps
+from scipy.integrate import simpson
 ##
 def extract_xstal_MI_name(*, files, char_xstal, pos_xstal, char_MI, pos_MI,
                          prefix=True, str_prefix=" ", file_ext='.txt'):
@@ -872,30 +872,30 @@ fit_sil='poly', dpi=200):
     ydat_sil=y_corr_sil
 
     xspace_sil=xdat_sil[1]-xdat_sil[0]
-    area_trap = trapz(y_corr_sil, dx=xspace_sil)
-    area_simps = simps(y_corr_sil, dx=xspace_sil)
+    area_trap = trapezoid(y_corr_sil, dx=xspace_sil)
+    area_simps = simpson(y_corr_sil, dx=xspace_sil)
     # Just the LW area
     xsil_LW=xdat_sil[(xdat_sil>LW[0]) & (xdat_sil<LW[1])]
     y_corr_sil_LW=y_corr_sil[(xdat_sil>LW[0]) & (xdat_sil<LW[1])]
     xspace_sil_LW=xsil_LW[1]-xsil_LW[0]
-    area_trap_LW=trapz(y_corr_sil_LW, dx=xspace_sil_LW)
-    area_simp_LW=simps(y_corr_sil_LW, dx=xspace_sil_LW)
+    area_trap_LW=trapezoid(y_corr_sil_LW, dx=xspace_sil_LW)
+    area_simp_LW=simpson(y_corr_sil_LW, dx=xspace_sil_LW)
 
 
     # Just the HW area
     xsil_HW=xdat_sil[(xdat_sil>HW[0]) & (xdat_sil<HW[1])]
     y_corr_sil_HW=y_corr_sil[(xdat_sil>HW[0]) & (xdat_sil<HW[1])]
     xspace_sil_HW=xsil_HW[1]-xsil_HW[0]
-    area_trap_HW=trapz(y_corr_sil_HW, dx=xspace_sil_HW)
-    area_simp_HW=simps(y_corr_sil_HW, dx=xspace_sil_HW)
+    area_trap_HW=trapezoid(y_corr_sil_HW, dx=xspace_sil_HW)
+    area_simp_HW=simpson(y_corr_sil_HW, dx=xspace_sil_HW)
 
     # MW
     if MW is not None:
         xsil_MW=xdat_sil[(xdat_sil>MW[0]) & (xdat_sil<MW[1])]
         y_corr_sil_MW=y_corr_sil[(xdat_sil>MW[0]) & (xdat_sil<MW[1])]
         xspace_sil_MW=xsil_MW[1]-xsil_MW[0]
-        area_trap_MW=trapz(y_corr_sil_MW, dx=xspace_sil_MW)
-        area_simp_MW=simps(y_corr_sil_MW, dx=xspace_sil_MW)
+        area_trap_MW=trapezoid(y_corr_sil_MW, dx=xspace_sil_MW)
+        area_simp_MW=simpson(y_corr_sil_MW, dx=xspace_sil_MW)
 
 
      # Plotting what its doing
@@ -1155,8 +1155,8 @@ def fit_area_for_water_region(*, path, filename, Spectra=None, config1: water_bc
 
 
     xspace_water=xdat_water[1]-xdat_water[0]
-    area_trap = trapz(y_corr_water, dx=xspace_water)
-    area_simps = simps(y_corr_water, dx=xspace_water)
+    area_trap = trapezoid(y_corr_water, dx=xspace_water)
+    area_simps = simpson(y_corr_water, dx=xspace_water)
 
 
      # Plotting what its doing

DiadFit/__init__.py

@@ -36,7 +36,7 @@ from DiadFit.error_propagation import *
 
 from DiadFit.density_depth_crustal_profiles import *
 from DiadFit.CO2_EOS import *
-from DiadFit.CO2_H2O_EOS import *
+
 
 from DiadFit.CO2_in_bubble_error import *
 

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.90'
+__version__ = '1.0.1'

DiadFit/densimeters.py

@@ -545,7 +545,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
             
             
             
-    elif lab=='CCMR':
+    elif lab=='CCMR' and temp=='SupCrit':
         pickle_str_lowr='Lowrho_polyfit_data_CCMR.pkl'
         with open(DiadFit_dir/pickle_str_lowr, 'rb') as f:
             lowrho_pickle_data = pickle.load(f)
@@ -557,11 +557,12 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
         # This gets the densimeter at high density.
         pickle_str_highr='Highrho_polyfit_data_CCMR.pkl'
         with open(DiadFit_dir/pickle_str_highr, 'rb') as f:
-            highrho_pickle_data = pickle.load(f)        
+            highrho_pickle_data = pickle.load(f)       
+            
         
     
     else:
-        raise TypeError('Lab name not recognised. enter CCMR or CMASS')
+        raise TypeError('Lab name not recognised. enter CCMR SupCrit, CMASS SupCrit, CMASS roomT (CCMR room T can be added on request to Penny)')
 
     # this allocates the model
     lowrho_model = lowrho_pickle_data['model']
@@ -627,7 +628,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     # If splitting is 0
     zero=df['Corrected_Splitting']==0
 
-
+    # Cut off values -------------------------------------------
     # Range for SC low density
     min_lowD_SC_Split=df['Corrected_Splitting']>=102.7623598753032
     max_lowD_SC_Split=df['Corrected_Splitting']<=103.1741034592534
@@ -643,6 +644,8 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     # Range for Room T high density
     min_HD_RoomT_Split=df['Corrected_Splitting']>=104.407308904012
     max_HD_RoomT_Split=df['Corrected_Splitting']<=105.1
+    
+
     # Impossible densities, room T
     Imposs_lower_end=(df['Corrected_Splitting']>103.350311768435) & (df['Corrected_Splitting']<103.88)
     # Impossible densities, room T
@@ -941,20 +944,29 @@ def merge_fit_files(path):
 
     if os.path.exists(os.path.join(path, 'Weak_Diads.xlsx')):
         grp1 = pd.read_excel(os.path.join(path, 'Weak_Diads.xlsx'))
+        grp1['Standard']='No'
     else:
         grp1 = None
 
     if os.path.exists(os.path.join(path, 'Medium_Diads.xlsx')):
         grp2 = pd.read_excel(os.path.join(path, 'Medium_Diads.xlsx'))
+        grp2['Standard']='No'
     else:
         grp2 = None
 
     if os.path.exists(os.path.join(path, 'Strong_Diads.xlsx')):
         grp3 = pd.read_excel(os.path.join(path, 'Strong_Diads.xlsx'))
+        grp3['Standard']='No'
     else:
         grp3 = None
+        
+    if os.path.exists(os.path.join(path, 'Std_Diads.xlsx')):
+        grp4 = pd.read_excel(os.path.join(path, 'Std_Diads.xlsx'))
+        grp4['Standard']='Yes'
+    else:
+        grp4 = None
 
-    df2 = pd.concat([grp1, grp2, grp3], axis=0).reset_index(drop=True)
+    df2 = pd.concat([grp1, grp2, grp3, grp4], axis=0).reset_index(drop=True)
 
     if discard is not None:
         discard_cols=discard[discard.columns.intersection(df2.columns)]

DiadFit/diads.py

@@ -18,7 +18,7 @@ import matplotlib.patches as patches
 import warnings as w
 from tqdm import tqdm
 from numpy import trapz
-from scipy.integrate import simps
+from scipy.integrate import simpson
 from scipy.interpolate import interp1d
 
 # Allowed models
@@ -725,7 +725,7 @@ def plot_peak_params(fit_params,
 def filter_splitting_prominence(*, fit_params, data_y_all,
                                 x_cord,
                                 splitting_limits=[100, 107],
-                                lower_diad1_prom=10, exclude_str):
+                                lower_diad1_prom=10, exclude_str=None, str_filt=None):
     """ Filters Spectra based on approximate splitting, draws a plot showing spectra to discard and those to keep
 
     Parameters
@@ -746,6 +746,12 @@ def filter_splitting_prominence(*, fit_params, data_y_all,
         Only keeps spectra that meet the splitting parameter, and have an absolute
         diad1 prominence greater than this value (helps filter out other weird spectra)
 
+    exclude_str: str
+        Excludes files with this string.
+
+    str_filt: str
+        Filters just based on string in filename
+
     Returns
     --------------
     fit_params_filt: pd.DataFrame
@@ -759,21 +765,30 @@ def filter_splitting_prominence(*, fit_params, data_y_all,
 
 
     """
+    if str_filt is not None:
+        filt=fit_params['filename'].str.contains(str_filt)
 
-    reas_split=(fit_params['approx_split'].between(splitting_limits[0], splitting_limits[1]))
-    reas_heigh=fit_params['Diad1_abs_prom']>lower_diad1_prom
-    if exclude_str is not None:
-        name_in_file=~fit_params['filename'].str.contains(exclude_str)
     else:
-        name_in_file=reas_heigh
 
-    fit_params_filt=fit_params.loc[(reas_split&reas_heigh&name_in_file)].reset_index(drop=True)
-    fit_params_disc=fit_params.loc[~(reas_split&reas_heigh&name_in_file)].reset_index(drop=True)
+        reas_split=(fit_params['approx_split'].between(splitting_limits[0], splitting_limits[1]))
+        reas_heigh=fit_params['Diad1_abs_prom']>lower_diad1_prom
+
+        if exclude_str is not None:
+            name_in_file=~fit_params['filename'].str.contains(exclude_str)
+        else:
+            name_in_file=reas_heigh
+
+        filt=reas_split&reas_heigh&name_in_file
+
+    fit_params_filt=fit_params.loc[filt].reset_index(drop=True)
+    fit_params_disc=fit_params.loc[~(filt)].reset_index(drop=True)
 
     print('Keeping N='+str(len(fit_params_filt)))
     print('Discarding N='+str(len(fit_params_disc)))
 
-    filt=reas_split&reas_heigh&name_in_file
+
+
+    # Then apply to get data
     data_y_filt=data_y_all[:, (filt)]
     data_y_disc=data_y_all[:, ~(filt)]
 
@@ -804,17 +819,21 @@ def filter_splitting_prominence(*, fit_params, data_y_all,
             Diff=np.nanmax(data_y_filt[:, i])-np.nanmin(data_y_filt[:, i])
             av_prom_Keep=fit_params_filt['Diad1_abs_prom'].iloc[i]
             prom_filt=prom_filt+av_prom_Keep
+            file=fit_params_filt['filename'].iloc[i]
             ax2.plot(x_cord+i*5, (data_y_filt[:, i]-np.nanmin(data_y_filt[:, i]))/Diff+i/3, '-b', lw=0.5)
+            yplot=np.quantile((data_y_filt[:, i]-np.nanmin(data_y_filt[:, i]))/Diff+i/3, 0.65)
+            ax2.annotate(str(file), xy=(1450+i*5, yplot),
+                    xycoords="data", fontsize=8, bbox=dict(facecolor='white', edgecolor='none', pad=2))
 
 
         ax2.set_xlim([1250, 1450+i*5])
         ax2.set_xticks([])
         ax2.set_yticks([])
 
-    return fit_params_filt, data_y_filt, fit_params_disc, data_y_disc
+    return fit_params_filt.reset_index(drop=True), data_y_filt, fit_params_disc.reset_index(drop=True), data_y_disc
 
 
-def identify_diad_group(*, fit_params, data_y,  x_cord, filter_bool,y_fig_scale=0.1, grp_filter='Weak'):
+def identify_diad_group(*, fit_params, data_y,  x_cord, filter_bool,y_fig_scale=0.1, grp_filter='Weak', str_filt=None):
 
     """Sorts diads into two groups. Those meeting the 'filter_bool' criteria, and those not
      meeting this criteria. Ones meeting the criteria are shown on the left hand plot,
@@ -853,6 +872,9 @@ def identify_diad_group(*, fit_params, data_y,  x_cord, filter_bool,y_fig_scale=
 
 
     """
+    if str_filt is not None:
+        filt_name=~fit_params['filename'].str.contains(str_filt)
+        filt_bool=filt_name&filt_bool
 
     if np.shape(data_y)[1]==0:
         Group1_df=pd.DataFrame().reindex_like(fit_params)
@@ -3835,8 +3857,8 @@ path=None, filename=None, filetype=None,
 
 
                 xspace_sil=x_new[1]-x_new[0]
-                area_trap = trapz(Baseline_ysub_sil, dx=xspace_sil)
-                area_simps = simps(Baseline_ysub_sil, dx=xspace_sil)
+                area_trap = trapezoid(Baseline_ysub_sil, dx=xspace_sil)
+                area_simps = simpson(Baseline_ysub_sil, dx=xspace_sil)