DiadFit 0.0.78__py3-none-any.whl → 0.0.80__py3-none-any.whl

DiadFit/diads.py

@@ -3,7 +3,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib import patches
 import lmfit
-from lmfit.models import GaussianModel, VoigtModel, LinearModel, ConstantModel, PseudoVoigtModel
+from lmfit.models import GaussianModel, VoigtModel, LinearModel, ConstantModel, PseudoVoigtModel, Pearson4Model
 from scipy.signal import find_peaks, gaussian
 import os
 import re
@@ -28,7 +28,7 @@ encode="ISO-8859-1"
 ## Ratio of different peaks
 
 def calculate_mole_fraction_2comp(peak_area_a, peak_area_b, cross_section_a, cross_section_b, instrument_eff_a, instrument_eff_b):
-    """ This function calculates the molar ration of 2 components a and b based on peak areas, 
+    """ This function calculates the molar ration of 2 components a and b based on peak areas,
     cross section and instrument efficiency
 
     Parameters
@@ -83,6 +83,9 @@ def plot_diad(*,path=None, filename=None, filetype='Witec_ASCII', Spectra_x=None
 
 
     """
+    if 'CRR' in filename:
+        filetype='headless_txt'
+
     if Spectra_x is None:
         Spectra_df=get_data(path=path, filename=filename, filetype=filetype)
 
@@ -141,7 +144,7 @@ class diad_id_config:
 
     Diad_window_width=30
 
-    Diad2_window: Tuple[float, float]=(approx_diad2_pos[0], approx_diad2_pos[1]+Diad_window_width)
+    Diad2_window: Tuple[float, float]=(approx_diad2_pos[0]-Diad_window_width, approx_diad2_pos[1]+Diad_window_width)
     Diad1_window: Tuple[float, float]=(approx_diad1_pos[0]-Diad_window_width, approx_diad1_pos[1])
 
     approx_diad2_pos_3peaks: Tuple[float, float]=(1379, 1395, 1379-17)
@@ -154,16 +157,16 @@ class diad_id_config:
 def identify_diad_peaks(*, config: diad_id_config=diad_id_config(), path=None, filename,
  filetype='Witec_ASCII',  plot_figure=True):
 
-    """ This function fits a spline to the spectral data. It then uses Scipy find peaks to identify the diad, 
-    HB and C13 peaks. It outputs parameters such as peak positions, peak prominences, 
+    """ This function fits a spline to the spectral data. It then uses Scipy find peaks to identify the diad,
+    HB and C13 peaks. It outputs parameters such as peak positions, peak prominences,
     and peak height ratios that can be very useful when splitting data into groups.
     It uses information stored in diad_id_config for most parameters
 
     Parameters
     -------------
     config: dataclass
-        This is diad_id_config, which you should edit before you feed into the function to adjust peak finding 
-        parameters. E.g. to change prominence of peaks found by scipy, do config=pf.diad_id_config(prominence=12), 
+        This is diad_id_config, which you should edit before you feed into the function to adjust peak finding
+        parameters. E.g. to change prominence of peaks found by scipy, do config=pf.diad_id_config(prominence=12),
         then input into this function
 
         Things that can be adjusted in this config file
@@ -977,7 +980,7 @@ def plot_diad_groups(*, x_cord,  Weak_np=None, Medium_np=None, Strong_np=None, y
 
     Returns
     -------------
-    figure showing 3 diad groups. 
+    figure showing 3 diad groups.
 
 
 
@@ -1268,8 +1271,10 @@ min_cent=None, max_cent=None, min_sigma=None, max_sigma=None, amplitude=100, min
         Model_combo=VoigtModel(prefix=prefix)#+ConstantModel(prefix=prefix) #Stops getting results
 
     if model_name == "PseudoVoigtModel":
-
         Model_combo=PseudoVoigtModel(prefix=prefix)#+ConstantModel(prefix=prefix) #Stops getting results
+
+    if model_name== "Pearson4Model":
+        Model_combo=Pearson4Model(prefix=prefix)#+ConstantModel(prefix=prefix) #Stops getting results
     peak =  Model_combo
     pars = peak.make_params()
 
@@ -1344,6 +1349,8 @@ class diad1_fit_config:
     # Do you want to return other parameters?
     return_other_params: bool =False
 
+
+
 @dataclass
 class diad2_fit_config:
     # Do you need a gaussian? Set position here if so
@@ -1399,7 +1406,7 @@ class diad2_fit_config:
 def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=None, filename=None, xdat=None, ydat=None, span=None,  plot_figure=True, dpi=200, Diad_pos=None, HB_pos=None, C13_pos=None, fit_peaks=None, block_print=True):
 
 
-    """ This function fits a voigt/Pseudovoigt curves to background subtracted data for your diads 
+    """ This function fits a voigt/Pseudovoigt curves to background subtracted data for your diads
     +- HBs+-C13 peaks. It can also fit a second Gaussian background iteratively with these peaks
 
 
@@ -1468,6 +1475,7 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
 
 
 
+
     # Calculate the amplitude from the sigma and the prominence
     calc_diad_amplitude=((config1.diad_sigma)*(config1.diad_prom))/0.3939
     calc_HB_amplitude=((config1.diad_sigma)*(config1.HB_prom))/0.3939
@@ -1498,8 +1506,12 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
 
     if config1.model_name=="VoigtModel":
         model_ini = VoigtModel()#+ ConstantModel()
-    if config1.model_name=="PseudoVoigtModel":
+    elif config1.model_name=="PseudoVoigtModel":
         model_ini = PseudoVoigtModel()#+ ConstantModel()
+    elif config1.model_name=='Pearson4Model':
+        model_ini = Pearson4Model()#+ ConstantModel()
+    else:
+        TypeError('Choice of model not yet supported - select VoigtModel, PseudoVoigtModel or Pearson4Model')
 
     # Create initial peak params
     # Set peak position to 2 spectral res units either side of the initial guess made above
@@ -1531,6 +1543,8 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
                 model_F = VoigtModel(prefix='lz1_') #+ ConstantModel(prefix='c1')
             if config1.model_name=='PseudoVoigtModel':
                 model_F = PseudoVoigtModel(prefix='lz1_') + ConstantModel(prefix='c1')
+            if config1.model_name=='Pearson4Model':
+                model_F = Pearson4Model(prefix='lz1_') + ConstantModel(prefix='c1')
 
             pars1 = model_F.make_params()
             pars1['lz1_'+ 'amplitude'].set(calc_diad_amplitude, min=0, max=calc_diad_amplitude*10)
@@ -1547,7 +1561,8 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
                 model1 = VoigtModel(prefix='lz1_')# + ConstantModel(prefix='c1')
             if config1.model_name=='PseudoVoigtModel':
                 model1 = PseudoVoigtModel(prefix='lz1_') #+ ConstantModel(prefix='c1')
-
+            if config1.model_name=='Pearson4Model':
+                model1 = Pearson4Model(prefix='lz1_') #+ ConstantModel(prefix='c1')
             pars1 = model1.make_params()
             pars1['lz1_'+ 'amplitude'].set(calc_diad_amplitude, min=0, max=calc_diad_amplitude*10)
 
@@ -1571,6 +1586,9 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
                     peak = VoigtModel(prefix='lz2_')# + ConstantModel(prefix='c1')
                 if config1.model_name=='PseudoVoigtModel':
                     peak = PseudoVoigtModel(prefix='lz2_')# + ConstantModel(prefix='c1')
+                if config1.model_name=='Pearson4Model':
+                    peak = Pearson4Model(prefix='lz2_')# + ConstantModel(prefix='c1')
+
 
                 pars = peak.make_params()
 
@@ -2264,9 +2282,9 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
 def fit_diad_2_w_bck(*, config1: diad2_fit_config=diad2_fit_config(), config2: diad_id_config=diad_id_config(),
     path=None, filename=None, peak_pos_voigt=None,filetype=None,
     plot_figure=True, close_figure=False, Diad_pos=None, HB_pos=None, C13_pos=None):
-    """ This function fits the background (using the function remove_diad_baseline) and then 
+    """ This function fits the background (using the function remove_diad_baseline) and then
     fits the peaks using fit_gaussian_voigt_generic_diad()
-    It then checks if any parameters are right at the permitted edge (meaning fitting didnt converge), 
+    It then checks if any parameters are right at the permitted edge (meaning fitting didnt converge),
     and tries fitting if so. Then it makes a plot
     of the various parts of the fitting procedure, and returns a dataframe of the fit parameters.
 
@@ -2367,6 +2385,8 @@ def fit_diad_2_w_bck(*, config1: diad2_fit_config=diad2_fit_config(), config2: d
 
 
     """
+    if 'CRR' in filename:
+        filetype='headless_txt'
 
     # Check number of peaks makes sense
     fit_peaks=config1.fit_peaks
@@ -2727,6 +2747,15 @@ def fit_diad_2_w_bck(*, config1: diad2_fit_config=diad2_fit_config(), config2: d
     if close_figure is True:
         plt.close(fig)
 
+    # Lets calculate peak skewness here.
+    Skew50=assess_diad2_skewness(config1=diad2_fit_config(), int_cut_off=0.5, path=path, filename=filename, filetype=filetype,
+    skewness='abs', height=1, prominence=5, width=0.5, plot_figure=False)
+    Skew80=assess_diad2_skewness(config1=diad2_fit_config(), int_cut_off=0.3, path=path, filename=filename, filetype=filetype,
+    skewness='abs', height=1, prominence=5, width=0.5, plot_figure=False)
+    df_out['Diad2_Asym50']=Skew50['Skewness_diad2']
+    df_out['Diad2_Asym70']=Skew80['Skewness_diad2']
+    df_out['Diad2_Yuan2017_sym_factor']=(df_out['Diad2_fwhm'])*(df_out['Diad2_Asym50']-1)
+    df_out['Diad2_Remigi2021_BSF']=df_out['Diad2_fwhm']/df_out['Diad2_Combofit_Height']
 
 
     if  config1.return_other_params is False:
@@ -2739,9 +2768,9 @@ def fit_diad_2_w_bck(*, config1: diad2_fit_config=diad2_fit_config(), config2: d
 
 def fit_diad_1_w_bck(*, config1: diad1_fit_config=diad1_fit_config(), config2: diad_id_config=diad_id_config(),
     path=None, filename=None, filetype=None,  plot_figure=True, close_figure=True, Diad_pos=None, HB_pos=None):
-    """ This function fits the background (using the function remove_diad_baseline) and then fits the peaks 
+    """ This function fits the background (using the function remove_diad_baseline) and then fits the peaks
     using fit_gaussian_voigt_generic_diad()
-    It then checks if any parameters are right at the permitted edge (meaning fitting didnt converge), 
+    It then checks if any parameters are right at the permitted edge (meaning fitting didnt converge),
     and tries fitting if so. Then it makes a plot
     of the various parts of the fitting procedure, and returns a dataframe of the fit parameters.
 
@@ -2836,6 +2865,8 @@ def fit_diad_1_w_bck(*, config1: diad1_fit_config=diad1_fit_config(), config2: d
 
 
 """
+    if 'CRR' in filename:
+        filetype='headless_txt'
 
     fit_peaks=config1.fit_peaks
 
@@ -3160,6 +3191,20 @@ def fit_diad_1_w_bck(*, config1: diad1_fit_config=diad1_fit_config(), config2: d
         if close_figure is True:
             plt.close(fig)
 
+    # Lets calculate peak skewness here.
+    Skew50=assess_diad1_skewness(config1=diad1_fit_config(), int_cut_off=0.5, path=path, filename=filename, filetype=filetype,
+    skewness='abs', height=1, prominence=5, width=0.5, plot_figure=False)
+    Skew80=assess_diad1_skewness(config1=diad1_fit_config(), int_cut_off=0.3, path=path, filename=filename, filetype=filetype,
+    skewness='abs', height=1, prominence=5, width=0.5, plot_figure=False)
+
+    df_out['Diad1_Asym50']=Skew50['Skewness_diad1']
+    df_out['Diad1_Asym70']=Skew80['Skewness_diad1']
+    df_out['Diad1_Yuan2017_sym_factor']=(df_out['Diad1_fwhm'])*(df_out['Diad1_Asym50']-1)
+    df_out['Diad1_Remigi2021_BSF']=df_out['Diad1_fwhm']/df_out['Diad1_Combofit_Height']
+
+
+
+
     if  config1.return_other_params is False:
         return df_out
     else:
@@ -3169,7 +3214,7 @@ def fit_diad_1_w_bck(*, config1: diad1_fit_config=diad1_fit_config(), config2: d
 def combine_diad_outputs(*, filename=None, prefix=True,
 Diad1_fit=None, Diad2_fit=None, to_csv=False,
 to_clipboard=False, path=None):
-    """ This function combines the dataframes from fit_diad_2_w_bck and fit_diad_1_w_bck into a 
+    """ This function combines the dataframes from fit_diad_2_w_bck and fit_diad_1_w_bck into a
     single dataframe
 
     Parameters
@@ -3226,12 +3271,19 @@ to_clipboard=False, path=None):
             combo['Diad2_Gauss_Area']=np.nan
             combo['Diad2_Gauss_Sigma']=np.nan
 
+
         combo['Splitting']=combo['Diad2_Voigt_Cent']-combo['Diad1_Voigt_Cent']
         #combo['Split_err_abs']=combo['Diad1_cent_err']+combo['Diad2_cent_err']
         combo['Split_σ']=(combo['Diad1_cent_err']**2+combo['Diad2_cent_err']**2)**0.5
         cols_to_move = ['Splitting', 'Split_σ',  'Diad1_Combofit_Cent', 'Diad1_cent_err', 'Diad1_Combofit_Height', 'Diad1_Voigt_Cent', 'Diad1_Voigt_Area', 'Diad1_Voigt_Sigma',  'Diad1_Residual', 'Diad1_Prop_Lor', 'Diad1_fwhm', 'Diad1_refit','Diad2_Combofit_Cent', 'Diad2_cent_err',  'Diad2_Combofit_Height', 'Diad2_Voigt_Cent', 'Diad2_Voigt_Area', 'Diad2_Voigt_Sigma', 'Diad2_Voigt_Gamma', 'Diad2_Residual', 'Diad2_Prop_Lor', 'Diad2_fwhm', 'Diad2_refit',
                     'HB1_Cent', 'HB1_Area', 'HB1_Sigma', 'HB2_Cent', 'HB2_Area', 'HB2_Sigma', 'C13_Cent', 'C13_Area', 'C13_Sigma',
-                    'Diad2_Gauss_Cent', 'Diad2_Gauss_Area','Diad2_Gauss_Sigma', 'Diad1_Gauss_Cent', 'Diad1_Gauss_Area','Diad1_Gauss_Sigma',]
+                    'Diad2_Gauss_Cent', 'Diad2_Gauss_Area','Diad2_Gauss_Sigma', 'Diad1_Gauss_Cent', 'Diad1_Gauss_Area','Diad1_Gauss_Sigma', 'Diad1_Asym50', 'Diad1_Asym70', 'Diad1_Yuan2017_sym_factor',
+'Diad1_Remigi2021_BSF','Diad2_Asym50', 'Diad2_Asym70', 'Diad2_Yuan2017_sym_factor',
+'Diad2_Remigi2021_BSF']
+
+
+
+
         combo_f = combo[cols_to_move + [
                 col for col in combo.columns if col not in cols_to_move]]
         combo_f=combo_f.iloc[:, 0:len(cols_to_move)]
@@ -3274,6 +3326,13 @@ to_clipboard=False, path=None):
 
 
 
+def calculate_HB_Diad_area_ratio(df):
+    """" Calculates two area ratios of hotbands and diads"""
+    df_c=df.copy()
+    df_c['HB_Diad_Ratio']=(df_c['HB1_Area']+df_c['HB2_Area'])/(df_c['Diad1_Voigt_Area']+df_c['Diad2_Voigt_Area'])
+    df_c['HB_Total_Ratio']=(df_c['HB1_Area']+df_c['HB2_Area'])/(df_c['Diad1_Voigt_Area']+df_c['Diad2_Voigt_Area']+df_c['HB1_Area']+df_c['HB2_Area'])
+    return df_c
+
 
 
 
@@ -3757,9 +3816,9 @@ path=None, filename=None, filetype=None,
         return df
 
 def peak_prominence(x, y, peak_position):
-    """ This function calculates the approximate prominence of a peak, 
+    """ This function calculates the approximate prominence of a peak,
     by finding the local minimum either side of the peak
-    
+
     Parameters
     ----------
     x: np.array
@@ -3772,7 +3831,7 @@ def peak_prominence(x, y, peak_position):
 
     Returns
     --------
-    float: prominence of peak in y coordinates. 
+    float: prominence of peak in y coordinates.
 
     """
     # Find the index of the peak position
@@ -3807,11 +3866,11 @@ from scipy.signal import find_peaks
 def plot_secondary_peaks(*, Diad_Files, path, filetype,
         xlim_plot=[1040, 1200], xlim_peaks=[1060, 1100],
         height=100, threshold=0.1, distance=10, prominence=5, width=6,
-         prominence_filter=False, sigma=3, sigma_window=30, find_peaks_filter=False, 
+         prominence_filter=False, sigma=3, sigma_window=30, find_peaks_filter=False,
          just_plot=False, yscale=0.2, gaussian_smooth=False, smoothing_window=5, smooth_std=3):
 
     """ This function plots spectra stacked vertically ontop of each other, in a specific region.
-    It also has two options to identify peak positions. 
+    It also has two options to identify peak positions.
 
     Parameters
     ---------------
@@ -3842,8 +3901,9 @@ def plot_secondary_peaks(*, Diad_Files, path, filetype,
     prominence_filter: bool
         if True, finds max y coordinate in the window xlim_peaks. It then calculates the prominence by
         comparing this peak height to the average of the median of the 3 datapoints at the left and right of the window.
-        If the peak is more than 'prominence' units above the average of these two end point medians, it 
+        If the peak is more than 'prominence' units above the average of these two end point medians, it
         is classified as a peak.
+        Also need to specify prominence: float
 
     find_peaks_filter: bool
 
@@ -3973,7 +4033,7 @@ def plot_secondary_peaks(*, Diad_Files, path, filetype,
             i=i+1
 
 
-        elif sigma_filter is True:
+        elif prominence_filter is True:
                 # Find max value in region
 
             maxy=np.max(y_trim)
@@ -4121,7 +4181,7 @@ encode="ISO-8859-1"
 
 
 def assess_diad1_skewness(*,  config1: diad1_fit_config=diad1_fit_config(), int_cut_off=0.3, path=None, filename=None, filetype=None,
-skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
+skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, peak_fit_routine=False, peak_pos=None, peak_height=None, dpi=200):
     """ Assesses Skewness of Diad peaks. Useful for identifying mixed L + V phases
     (see DeVitre et al. in review)
 
@@ -4168,6 +4228,9 @@ skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
     dpi: int
         dpi to save image at
 
+    peak_fit_routine: bool (default False) -
+        if True, doesnt find max of spline, but uses the peak position you have found from the diad fitting functions.
+        Also needs peak_pos (peak center in cm-1) and peak_height
 
 
     Returns
@@ -4202,20 +4265,28 @@ skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
 
 
     # Use Scipy find peaks to get the biggest peak
-    height=height
-    peaks = find_peaks(y_cub, height=height, prominence=prominence, width=width)
-    peak_height=peaks[1]['peak_heights']
-    peak_pos = x_new[peaks[0]]
+    if peak_fit_routine is False:
+        height=height
+        peaks = find_peaks(y_cub, height=height, prominence=prominence, width=width)
+        peak_height=peaks[1]['peak_heights']
+        peak_pos = x_new[peaks[0]]
 
-    # find max peak.  put into df because i'm lazy
-    peak_df=pd.DataFrame(data={'pos': peak_pos,
-                        'height': peak_height})
 
-    # Find bigest peaks,
-    df_peak_sort=peak_df.sort_values('height', axis=0, ascending=False)
-    df_peak_sort_trim=df_peak_sort[0:1]
-    Peak_Center=df_peak_sort_trim['pos']
-    Peak_Height=df_peak_sort_trim['height']
+        # find max peak.  put into df because i'm lazy
+        peak_df=pd.DataFrame(data={'pos': peak_pos,
+                            'height': peak_height})
+
+        # Find bigest peaks,
+        df_peak_sort=peak_df.sort_values('height', axis=0, ascending=False)
+        df_peak_sort_trim=df_peak_sort[0:1]
+        Peak_Center=df_peak_sort_trim['pos']
+        Peak_Height=df_peak_sort_trim['height']
+
+    # now we are using peak parameters we got from Voigt/Pseudovoigt etc.
+    if peak_fit_routine is True:
+        Peak_Height=peak_height
+        Peak_Center=peak_pos
+
 
 
     # Find intensity cut off
@@ -4362,9 +4433,8 @@ skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
 
 
 
-
 def assess_diad2_skewness(*,  config1: diad2_fit_config=diad1_fit_config(), int_cut_off=0.3, path=None, filename=None, filetype=None,
-skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
+skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200, peak_fit_routine=False, peak_pos=None, peak_height=None):
 
     """ Assesses Skewness of Diad peaks. Useful for identifying mixed L + V phases
     (see DeVitre et al. in review)
@@ -4412,6 +4482,10 @@ skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
     dpi: int
         dpi to save image at
 
+    peak_fit_routine: bool (default False) -
+        if True, doesnt find max of spline, but uses the peak position you have found from the diad fitting functions.
+        Also needs peak_pos (peak center in cm-1) and peak_height
+
 
 
     Returns
@@ -4444,21 +4518,24 @@ skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
     y_cub=f2(x_new)
 
 
-
+    if peak_fit_routine is False:
 # Use Scipy find peaks to get that cubic peak
-    peaks = find_peaks(y_cub, height=height, prominence=prominence, width=width)
-    peak_height=peaks[1]['peak_heights']
-    peak_pos = x_new[peaks[0]]
+        peaks = find_peaks(y_cub, height=height, prominence=prominence, width=width)
+        peak_height=peaks[1]['peak_heights']
+        peak_pos = x_new[peaks[0]]
 
-    # find max peak.  put into df because i'm lazy
-    peak_df=pd.DataFrame(data={'pos': peak_pos,
-                        'height': peak_height})
+        # find max peak.  put into df because i'm lazy
+        peak_df=pd.DataFrame(data={'pos': peak_pos,
+                            'height': peak_height})
 
-    df_peak_sort=peak_df.sort_values('height', axis=0, ascending=False)
-    df_peak_sort_trim=df_peak_sort[0:1]
-    Peak_Center=df_peak_sort_trim['pos'].iloc[0]
-    Peak_Height=df_peak_sort_trim['height'].iloc[0]
+        df_peak_sort=peak_df.sort_values('height', axis=0, ascending=False)
+        df_peak_sort_trim=df_peak_sort[0:1]
+        Peak_Center=df_peak_sort_trim['pos'].iloc[0]
+        Peak_Height=df_peak_sort_trim['height'].iloc[0]
 
+    if peak_fit_routine is True:
+        Peak_Height=peak_height[0]
+        Peak_Center=peak_pos[0]
 
 
 
@@ -4600,7 +4677,7 @@ skewness='abs', height=1, prominence=5, width=0.5, plot_figure=True, dpi=200):
 
 def loop_diad_skewness(*, Diad_files, path=None, filetype=None,  skewness='abs', sort=False, int_cut_off=0.15,
 config_diad1: diad1_fit_config=diad1_fit_config(), config_diad2: diad2_fit_config=diad2_fit_config(), prominence=10, width=1, height=1):
-    """ Loops over all supplied files to calculate skewness for multiple spectra using the functions 
+    """ Loops over all supplied files to calculate skewness for multiple spectra using the functions
     assess_diad1_skewness() and assess_diad2_skewness()
 
 

DiadFit/error_propagation.py

@@ -59,14 +59,16 @@ def make_error_dist_microthermometry_1sam(*, T_h_C, sample_i=0, error_T_h_C=0.3,
     if error_dist_T_h_C=='uniform':
         Noise_to_add_T_h_C = np.random.uniform(- error_T_h_C, +
                                                       error_T_h_C, N_dup)
-
-    T_h_C_with_noise=Noise_to_add_T_h_C+df_c['T_h_C'].iloc[sample_i]
+    
+    T_h_C_with_noise=Noise_to_add_T_h_C+df_c['T_h_C'].iloc[0]
+    
+    
 
     return T_h_C_with_noise
 
 
 def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0.3, N_dup=1000,
-        error_dist_T_h_C='uniform', error_type_T_h_C='Abs', EOS='SW96',  homog_to=None):
+        error_dist_T_h_C='uniform', error_type_T_h_C='Abs', EOS='SW96',  homog_to=None, set_to_critical=False):
 
     """
     This function propagates the uncertainty in measured temperature values to calculate the density of gas and
@@ -108,6 +110,10 @@ def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0
 
     homog_to : str, optional
         The phase to which the CO2 density is homogenized. Can be either 'Gas' or 'Liq'. Default is None.
+        
+    set_to_critical: bool
+        Default False. If true, if you enter T_h_C which exceeds 30.9782 (the critical point of CO2) it replaces your entered Temp with that temp.
+        
 
     Returns
     -------
@@ -135,6 +141,7 @@ def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0
     Mean_density_gas=np.empty(len_loop)
     Mean_density_liq=np.empty(len_loop)
     Std_density_gas_IQR=np.empty(len_loop)
+    Std_density_Liq_IQR=np.empty(len_loop)
     Sample=np.empty(len_loop,  dtype=np.dtype('U100') )
 
     for i in range(0, len_loop):
@@ -166,6 +173,7 @@ def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0
         Sample2=Sample[i]
         MC_T=calculate_CO2_density_homog_T(T_h_C=Temp_MC, Sample_ID=Sample2, EOS=EOS, homog_to=homog_to)
 
+        # Replace critical with NaN
 
 
 
@@ -179,15 +187,22 @@ def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0
         Mean_density_liq[i]=np.nanmean(MC_T['Liq_gcm3'])
         var=MC_T['Gas_gcm3']
         Std_density_gas_IQR[i]=0.5*np.abs((np.percentile(var, 84) -np.percentile(var, 16)))
+        varL=MC_T['Liq_gcm3']
+        Std_density_Liq_IQR[i]=0.5*np.abs((np.percentile(varL, 84) -np.percentile(varL, 16)))
 
-
+    # Preferred density no MC
+    Density_pref=calculate_CO2_density_homog_T(T_h_C=T_h_C, Sample_ID=Sample_ID, EOS=EOS, homog_to=homog_to, set_to_critical=set_to_critical)
 
     Av_outputs=pd.DataFrame(data={'Sample_ID': Sample,
+                                    'Density_Gas_noMC': Density_pref['Gas_gcm3'],
+                                    'Density_Liq_noMC': Density_pref['Liq_gcm3'],
                                       'Mean_density_Gas_gcm3': Mean_density_gas,
                                       'Std_density_Gas_gcm3': Std_density_gas,
                                       'Std_density_Gas_gcm3_from_percentiles': Std_density_gas_IQR,
+                                      'Std_density_Liq_gcm3_from_percentiles': Std_density_Liq_IQR,
                                        'Mean_density_Liq_gcm3': Mean_density_liq,
                                       'Std_density_Liq_gcm3': Std_density_liq,
+                                      'Input_temp': T_h_C,
                                       'error_T_h_C': error_T_h_C})
 
 

DiadFit/importing_data_files.py

@@ -195,7 +195,7 @@ def get_data(*, path=None, filename=None, Diad_files=None, filetype='Witec_ASCII
 
     
     if np.all(np.diff(x_values) < 0):
-        print('I flipped')
+        #print('I flipped')
         np_in = np.flipud(np_in)
     # print(df_in)
     # print('finish this bit')
@@ -1194,6 +1194,42 @@ def stitch_loop_individual_fits(*, fit_individually=True,
     
 ## Save settings files
 def save_settings(meta_path, spectra_path, filetype, prefix, prefix_str, file_ext, TruPower):
+    """ This function saves settings so you can load them across multiple notebooks without repition
+    
+    Parameters
+    -------------------
+    meta_path: str
+        Path where your metadata is stored
+    spectra_path: str
+        path where your spectra is stored
+    filetype: str
+        Choose from 'Witec_ASCII', 'headless_txt', 'headless_csv', 'head_csv', 'Witec_ASCII', 'HORIBA_txt', 'Renishaw_txt'
+    prefix: bool
+        If True, removes 01, 02, from filename (WITEC problem)
+        Also need to state prefix_str: prefix separating string (in this case, 01 Ne would be ' '
+        
+    file_ext: str
+        Extension of file. e.g. txt
+    
+    TruPower: bool
+        If WITEC instrument and you have TruPower, set as True
+        
+    Returns
+    --------------
+    file called settings.txt with these saved.
+    
+    
+    """
+    filetype_opts = ['Witec_ASCII', 'headless_txt', 'headless_csv', 'head_csv', 'Witec_ASCII', 'HORIBA_txt', 'Renishaw_txt']
+    
+    
+    if filetype in filetype_opts:
+            # Proceed with your logic here
+        print(f"Filetype {filetype} is valid.")
+            # You can add more logic here if needed
+    else:
+        raise TypeError(f"Invalid filetype: {filetype}. Supported filetypes are {filetype_opts}")
+
     # Get the current folder
     folder = os.getcwd()