DiadFit 1.0.9__py3-none-any.whl → 1.0.10__py3-none-any.whl

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__ = '1.0.9'
+__version__ = '1.0.10'

DiadFit/densimeters.py

@@ -1370,6 +1370,9 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
 
     return df_merge
     
+    
+
+
     ## Method from FLuids laboratory from FRANCIS Program
     
 
@@ -1433,3 +1436,618 @@ def Francis_pureCO2(FDS, FDS_std, uncer_FDS, uncer_FDS_std=0):
     return df
 
 
+## Shifted polynomial
+
+import pickle
+
+def blend_weights(x, x_min, x_max):
+    """Cosine smooth blend between x_min and x_max."""
+    t = np.clip((x - x_min) / (x_max - x_min), 0, 1)
+    return 0.5 * (1 - np.cos(np.pi * t))
+
+def build_piecewise_poly_by_density(x, y, y_bounds=(0.17, 0.65), degrees=(1, 3, 2), blend_width=0.05, save_path=None):
+    """
+    Fits and optionally saves a smoothed piecewise polynomial model.
+
+    Returns:
+        f_base : callable
+        model_data : dict (can be pickled)
+    """
+    x = np.asarray(x)
+    y = np.asarray(y)
+
+    mask_low = y < y_bounds[0]
+    mask_mid = (y >= y_bounds[0]) & (y <= y_bounds[1])
+    mask_high = y > y_bounds[1]
+
+    polys = []
+    coeffs = []
+    for mask, deg in zip([mask_low, mask_mid, mask_high], degrees):
+        c = np.polyfit(x[mask], y[mask], deg)
+        coeffs.append(c)
+        polys.append(np.poly1d(c))
+
+    x_low_med = x[np.abs(y - y_bounds[0]).argmin()]
+    x_med_high = x[np.abs(y - y_bounds[1]).argmin()]
+
+    def f_base(x_input):
+        x_arr = np.asarray(x_input)
+        result = np.full_like(x_arr, np.nan, dtype=float)
+
+        low_mask = x_arr < (x_low_med - blend_width)
+        mid_mask = (x_arr > (x_low_med + blend_width)) & (x_arr < (x_med_high - blend_width))
+        high_mask = x_arr > (x_med_high + blend_width)
+
+        result[low_mask] = polys[0](x_arr[low_mask])
+        result[mid_mask] = polys[1](x_arr[mid_mask])
+        result[high_mask] = polys[2](x_arr[high_mask])
+
+        blend_lm = (x_arr >= (x_low_med - blend_width)) & (x_arr <= (x_low_med + blend_width))
+        w_lm = blend_weights(x_arr[blend_lm], x_low_med - blend_width, x_low_med + blend_width)
+        result[blend_lm] = (1 - w_lm) * polys[0](x_arr[blend_lm]) + w_lm * polys[1](x_arr[blend_lm])
+
+        blend_mh = (x_arr >= (x_med_high - blend_width)) & (x_arr <= (x_med_high + blend_width))
+        w_mh = blend_weights(x_arr[blend_mh], x_med_high - blend_width, x_med_high + blend_width)
+        result[blend_mh] = (1 - w_mh) * polys[1](x_arr[blend_mh]) + w_mh * polys[2](x_arr[blend_mh])
+
+        return result
+
+    model_data = {
+        'coeffs': coeffs,
+        'y_bounds': y_bounds,
+        'degrees': degrees,
+        'blend_width': blend_width,
+        'x_low_med': x_low_med,
+        'x_med_high': x_med_high,
+        'x': x,             
+        'y': y              
+    }
+    if save_path:
+        with open(save_path, 'wb') as f:
+            pickle.dump(model_data, f)
+
+    return f_base, model_data
+    
+    
+def blend_weights(x, x_min, x_max):
+    t = np.clip((x - x_min) / (x_max - x_min), 0, 1)
+    return 0.5 * (1 - np.cos(np.pi * t))
+
+def load_piecewise_model(model_data):
+    coeffs = model_data['coeffs']
+    blend_width = model_data['blend_width']
+    x_low_med = model_data['x_low_med']
+    x_med_high = model_data['x_med_high']
+    polys = [np.poly1d(c) for c in coeffs]
+
+    vertical_shift = model_data.get('vertical_shift', 0)
+
+    def f_base(x_input):
+        x_arr = np.asarray(x_input)
+        result = np.full_like(x_arr, np.nan, dtype=float)
+
+        low_mask = x_arr < (x_low_med - blend_width)
+        mid_mask = (x_arr > (x_low_med + blend_width)) & (x_arr < (x_med_high - blend_width))
+        high_mask = x_arr > (x_med_high + blend_width)
+
+        result[low_mask] = polys[0](x_arr[low_mask])
+        result[mid_mask] = polys[1](x_arr[mid_mask])
+        result[high_mask] = polys[2](x_arr[high_mask])
+
+        blend_lm = (x_arr >= (x_low_med - blend_width)) & (x_arr <= (x_low_med + blend_width))
+        w_lm = blend_weights(x_arr[blend_lm], x_low_med - blend_width, x_low_med + blend_width)
+        result[blend_lm] = (1 - w_lm) * polys[0](x_arr[blend_lm]) + w_lm * polys[1](x_arr[blend_lm])
+
+        blend_mh = (x_arr >= (x_med_high - blend_width)) & (x_arr <= (x_med_high + blend_width))
+        w_mh = blend_weights(x_arr[blend_mh], x_med_high - blend_width, x_med_high + blend_width)
+        result[blend_mh] = (1 - w_mh) * polys[1](x_arr[blend_mh]) + w_mh * polys[2](x_arr[blend_mh])
+
+        return result + vertical_shift  
+
+    return f_base
+
+
+
+
+## New function that is much simpler
+
+def calculate_density_ucb_new(*, df_combo=None, temp='SupCrit', 
+CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, corrected_split=None, split_err=None, shift=0):
+    """ This function converts Diad Splitting into CO$_2$ density using the UC Berkeley calibration line
+    developed by DeVitre and Wieser in 2023. 
+
+    Parameters
+    -------------
+    Ne_line_combo: str, '1117_1447', '1117_1400', '1220_1447', '1220_1400', '1220_1567'
+        Combination of Ne lines used for drift correction
+        
+    Either:
+
+    df_combo: pandas DataFrame
+        data frame of peak fitting information
+        
+    Or:
+    corrected_split: pd.Series
+        Corrected splitting  (cm-1)  
+        
+    split_err: float, int
+        Error on corrected splitting
+
+    temp: str
+        'SupCrit' if measurements done at 37C
+        'RoomT' if measurements done at 24C - Not supported yet but could be added if needed. 
+
+    CI_neon: float
+        Default 0.67. Confidence interval to use, e.g. 0.67 returns 1 sigma uncertainties. If you use another number,
+        note the column headings will still say sigma.
+
+    CI_split: float
+        Default 0.67. Confidence interval to use, e.g. 0.67 returns 1 sigma uncertainties. If you use another number,
+        note the column headings will still say sigma.
+        
+        
+
+
+    Either
+
+    Ne_pickle_str: str
+        Name of Ne correction model
+
+    OR
+
+    pref_Ne, Ne_err: float, int
+        For quick and dirty fitting can pass a preferred value for your instrument before you have a chance to 
+        regress the Ne lines (useful when first analysing new samples. )
+
+
+
+
+    Returns
+    --------------
+    pd.DataFrame
+        Prefered Density (based on different equatoins being merged), and intermediate calculations
+
+    """
+    if corrected_split is not None:
+        Split=corrected_split
+    if df_combo is not None:
+        df_combo_c=df_combo.copy()
+        time=df_combo_c['sec since midnight']
+
+        if Ne_pickle_str is not None:
+
+            # Calculating the upper and lower values for Ne to get that error
+            Ne_corr=calculate_Ne_corr_std_err_values(pickle_str=Ne_pickle_str,
+            new_x=time, CI=CI_neon)
+            # Extracting preferred correction values
+            pref_Ne=Ne_corr['preferred_values']
+            Split_err, pk_err=propagate_error_split_neon_peakfit(Ne_corr=Ne_corr, df_fits=df_combo_c)
+
+            df_combo_c['Corrected_Splitting_σ']=Split_err
+            df_combo_c['Corrected_Splitting_σ_Ne']=(Ne_corr['upper_values']*df_combo_c['Splitting']-Ne_corr['lower_values']*df_combo_c['Splitting'])/2
+            df_combo_c['Corrected_Splitting_σ_peak_fit']=pk_err
+
+        # If using a single value for quick dirty fitting
+        else:
+            Split_err, pk_err=propagate_error_split_neon_peakfit(df_fits=df_combo_c, Ne_err=Ne_err, pref_Ne=pref_Ne)
+
+
+
+            df_combo_c['Corrected_Splitting_σ']=Split_err
+
+            df_combo_c['Corrected_Splitting_σ_Ne']=((Ne_err+pref_Ne)*df_combo_c['Splitting']-(Ne_err-pref_Ne)*df_combo_c['Splitting'])/2
+            df_combo_c['Corrected_Splitting_σ_peak_fit']=pk_err
+
+        Split=df_combo_c['Splitting']*pref_Ne
+
+    else:
+       Split_err=split_err
+
+
+
+    # This is for if you just have splitting
+
+
+
+    # This propgates the uncertainty in the splitting from peak fitting, and the Ne correction model
+
+
+    if temp=='RoomT':
+        raise TypeError('Sorry, no UC Berkeley calibration at 24C, please enter temp=SupCrit')
+    if isinstance(Split, float) or isinstance(Split, int):
+        Split=pd.Series(Split)
+        
+    
+    DiadFit_dir=Path(__file__).parent
+    
+    # load the new smoothed model
+    with open(DiadFit_dir / "smoothed_polyfit_June25_UCB.pkl", 'rb') as f:
+        smoothed_model_data = pickle.load(f)
+        
+    smoothed_model = load_piecewise_model(smoothed_model_data)
+
+    # Evaluate model
+    Density = pd.Series(smoothed_model(Split), index=Split.index)   
+    
+    # Lets get the error
+    err_df = calculate_Densimeter_std_err_values_smooth(
+        model_data=smoothed_model_data,
+        corrected_split=Split,
+        corrected_split_err=Split_err,
+        CI_dens=0.67,
+        CI_split=0.67,
+        str_d='Smoothed'
+    )
+    
+
+    
+    
+    df=pd.DataFrame(data={'Density g/cm3': Density+shift,
+                                'σ Density g/cm3': err_df['Smoothed_Density_σ'],
+                                'σ Density g/cm3 (from Ne+peakfit)': err_df['Smoothed_Density_σ_split'],
+                                'σ Density g/cm3 (from densimeter)': err_df['Smoothed_Density_σ_dens'],                                            
+                                'Corrected_Splitting': Split,
+                                'Preferred D_σ_Ne': 0,
+                                'in range': 'in progress',
+                                'Temperature': temp})
+            
+
+    if Ne_pickle_str is not None:
+        df_merge1=pd.concat([df_combo_c, Ne_corr], axis=1).reset_index(drop=True)
+        df_merge=pd.concat([df, df_merge1], axis=1).reset_index(drop=True)
+    elif Ne_pickle_str is None and df_combo is not None:
+        df_merge=pd.concat([df, df_combo_c], axis=1).reset_index(drop=True)
+    else:
+        df_merge=df
+
+    
+
+    if Ne_pickle_str is not None: # If its not none, have all the columns for Ne
+        cols_to_move = ['filename', 'Density g/cm3', 'σ Density g/cm3','σ Density g/cm3 (from Ne+peakfit)', 'σ Density g/cm3 (from densimeter)',
+        'Corrected_Splitting', 'Corrected_Splitting_σ',
+        'Corrected_Splitting_σ_Ne', 'Corrected_Splitting_σ_peak_fit', 'power (mW)', 'Spectral Center']
+        df_merge = df_merge[cols_to_move + [
+            col for col in df_merge.columns if col not in cols_to_move]]
+            
+            
+    elif pref_Ne is not None and df_combo is not None: #If Pref Ne, 
+        cols_to_move = ['filename', 'Density g/cm3', 'σ Density g/cm3','σ Density g/cm3 (from Ne+peakfit)', 'σ Density g/cm3 (from densimeter)',
+        'Corrected_Splitting', 'Corrected_Splitting_σ',
+        'Corrected_Splitting_σ_Ne', 'Corrected_Splitting_σ_peak_fit']
+        df_merge = df_merge[cols_to_move + [
+            col for col in df_merge.columns if col not in cols_to_move]]
+            
+    elif df_combo is None:
+        
+        cols_to_move = ['Density g/cm3', 'σ Density g/cm3','σ Density g/cm3 (from Ne+peakfit)', 'σ Density g/cm3 (from densimeter)',
+        'Corrected_Splitting']
+        df_merge = df_merge[cols_to_move + [
+            col for col in df_merge.columns if col not in cols_to_move]]
+
+
+
+    return df_merge
+    
+from scipy.stats import t
+import numpy as np
+import pandas as pd
+
+
+
+
+##
+def calculate_Densimeter_std_err_values_smooth(
+    *,
+    model_data,
+    corrected_split,
+    corrected_split_err,
+    CI_dens=0.67,
+    CI_split=0.67,
+    str_d='Smoothed',
+    x=None,
+    y=None
+):
+    """
+    Calculates propagated uncertainty for a smoothed polynomial model.
+
+    Parameters
+    ----------
+    model_data : dict
+        Dictionary from build_piecewise_poly_by_density including coeffs, blend_width, etc.
+    corrected_split : pd.Series or np.ndarray
+        Corrected splitting values
+    corrected_split_err : float or pd.Series
+        Uncertainty on splitting
+    CI_dens : float
+        Confidence interval for uncertainty in the fit
+    CI_split : float
+        Confidence interval for splitting uncertainty
+    str_d : str
+        Prefix for column names
+    x, y : array-like (optional)
+        Original data used to fit the model, if not included in model_data
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame of predicted values and propagated uncertainties
+    """
+    from scipy.stats import t
+    import numpy as np
+    import pandas as pd
+
+    # === Rebuild model ===
+    def load_piecewise_model(model_data):
+        coeffs = model_data['coeffs']
+        blend_width = model_data['blend_width']
+        x_low_med = model_data['x_low_med']
+        x_med_high = model_data['x_med_high']
+        polys = [np.poly1d(c) for c in coeffs]
+
+        def f_base(x_input):
+            x_arr = np.asarray(x_input)
+            result = np.full_like(x_arr, np.nan, dtype=float)
+
+            low_mask = x_arr < (x_low_med - blend_width)
+            mid_mask = (x_arr > (x_low_med + blend_width)) & (x_arr < (x_med_high - blend_width))
+            high_mask = x_arr > (x_med_high + blend_width)
+
+            result[low_mask] = polys[0](x_arr[low_mask])
+            result[mid_mask] = polys[1](x_arr[mid_mask])
+            result[high_mask] = polys[2](x_arr[high_mask])
+
+            blend_lm = (x_arr >= (x_low_med - blend_width)) & (x_arr <= (x_low_med + blend_width))
+            w_lm = 0.5 * (1 - np.cos(np.pi * (x_arr[blend_lm] - (x_low_med - blend_width)) / (2 * blend_width)))
+            result[blend_lm] = (1 - w_lm) * polys[0](x_arr[blend_lm]) + w_lm * polys[1](x_arr[blend_lm])
+
+            blend_mh = (x_arr >= (x_med_high - blend_width)) & (x_arr <= (x_med_high + blend_width))
+            w_mh = 0.5 * (1 - np.cos(np.pi * (x_arr[blend_mh] - (x_med_high - blend_width)) / (2 * blend_width)))
+            result[blend_mh] = (1 - w_mh) * polys[1](x_arr[blend_mh]) + w_mh * polys[2](x_arr[blend_mh])
+
+            return result
+
+        return f_base
+
+    Pf = load_piecewise_model(model_data)
+
+    # Use x/y from model_data if available, else require them as args
+    if 'x' in model_data and 'y' in model_data:
+        x = model_data['x']
+        y = model_data['y']
+    elif x is None or y is None:
+        raise ValueError("You must supply x and y arrays if not included in model_data.")
+
+    residuals = y - Pf(x)
+    residual_std = np.std(residuals)
+
+    mean_x = np.nanmean(x)
+    n = len(x)
+    N_poly = max(len(c) - 1 for c in model_data['coeffs'])
+
+    # Standard error on predictions
+    standard_errors = residual_std * np.sqrt(1 + 1/n + (corrected_split - mean_x)**2 / np.sum((x - mean_x)**2))
+    dfree = n - (N_poly + 1)
+
+    t_value_split = t.ppf((1 + CI_split) / 2, dfree)
+    t_value_dens = t.ppf((1 + CI_dens) / 2, dfree)
+
+    # Central prediction
+    preferred_values = Pf(corrected_split)
+    lower_values = preferred_values - t_value_dens * standard_errors
+    upper_values = preferred_values + t_value_dens * standard_errors
+    uncertainty_from_dens = (upper_values - lower_values) / 2
+
+    # Splitting propagation
+    max_split = corrected_split + corrected_split_err
+    min_split = corrected_split - corrected_split_err
+    max_density = Pf(max_split)
+    min_density = Pf(min_split)
+    uncertainty_split = (max_density - min_density) / 2
+
+    total_uncertainty = np.sqrt(uncertainty_split ** 2 + uncertainty_from_dens ** 2)
+
+    return pd.DataFrame({
+        f'{str_d}_Density': preferred_values,
+        f'{str_d}_Density_σ': total_uncertainty,
+        f'{str_d}_Density+1σ': preferred_values - total_uncertainty,
+        f'{str_d}_Density-1σ': preferred_values + total_uncertainty,
+        f'{str_d}_Density_σ_dens': uncertainty_from_dens,
+        f'{str_d}_Density_σ_split': uncertainty_split
+    })
+    
+    
+from pathlib import Path
+import pickle
+
+def calculate_density_labx(
+    *,
+    df_combo=None,
+    temp='SupCrit',
+    CI_split=0.67,
+    CI_neon=0.67,
+    Ne_pickle_str=None,
+    pref_Ne=None,
+    Ne_err=None,
+    corrected_split=None,
+    split_err=None,
+    model_pickle_path=None
+):
+    import pandas as pd
+    import numpy as np
+    from DiadFit.densimeters import calculate_Ne_corr_std_err_values, propagate_error_split_neon_peakfit
+    from DiadFit.densimeters import calculate_Densimeter_std_err_values_smooth, load_piecewise_model
+
+    if corrected_split is not None:
+        Split = corrected_split
+
+    if df_combo is not None:
+        df_combo_c = df_combo.copy()
+        time = df_combo_c['sec since midnight']
+
+        if Ne_pickle_str is not None:
+            Ne_corr = calculate_Ne_corr_std_err_values(pickle_str=Ne_pickle_str, new_x=time, CI=CI_neon)
+            pref_Ne = Ne_corr['preferred_values']
+            Split_err, pk_err = propagate_error_split_neon_peakfit(Ne_corr=Ne_corr, df_fits=df_combo_c)
+            df_combo_c['Corrected_Splitting_σ'] = Split_err
+            df_combo_c['Corrected_Splitting_σ_Ne'] = (
+                (Ne_corr['upper_values'] * df_combo_c['Splitting'] -
+                 Ne_corr['lower_values'] * df_combo_c['Splitting']) / 2
+            )
+            df_combo_c['Corrected_Splitting_σ_peak_fit'] = pk_err
+        else:
+            Split_err, pk_err = propagate_error_split_neon_peakfit(
+                df_fits=df_combo_c, Ne_err=Ne_err, pref_Ne=pref_Ne
+            )
+            df_combo_c['Corrected_Splitting_σ'] = Split_err
+            df_combo_c['Corrected_Splitting_σ_Ne'] = (
+                ((Ne_err + pref_Ne) * df_combo_c['Splitting'] -
+                 (Ne_err - pref_Ne) * df_combo_c['Splitting']) / 2
+            )
+            df_combo_c['Corrected_Splitting_σ_peak_fit'] = pk_err
+
+        Split = df_combo_c['Splitting'] * pref_Ne
+    else:
+        Split_err = split_err
+
+    if temp == 'RoomT':
+        raise TypeError('No calibration available at 24C, please use temp="SupCrit"')
+    if isinstance(Split, (float, int)):
+        import pandas as pd
+        Split = pd.Series(Split)
+
+    if model_pickle_path is None:
+        raise ValueError("You must provide a path to the LabX model pickle using `model_pickle_path`.")
+
+    with open(Path(model_pickle_path), 'rb') as f:
+        model_data = pickle.load(f)
+
+    model = load_piecewise_model(model_data)
+    Density = pd.Series(model(Split), index=Split.index)
+
+    err_df = calculate_Densimeter_std_err_values_smooth(
+        model_data=model_data,
+        corrected_split=Split,
+        corrected_split_err=Split_err,
+        CI_dens=CI_split,
+        CI_split=CI_split,
+        str_d='LabX'
+    )
+
+    df = pd.DataFrame(data={
+        'Density g/cm3': Density,
+        'σ Density g/cm3': err_df['LabX_Density_σ'],
+        'σ Density g/cm3 (from Ne+peakfit)': err_df['LabX_Density_σ_split'],
+        'σ Density g/cm3 (from densimeter)': err_df['LabX_Density_σ_dens'],
+        'Corrected_Splitting': Split,
+        'Preferred D_σ_Ne': 0,
+        'in range': 'in progress',
+        'Temperature': temp
+    })
+
+    if Ne_pickle_str is not None:
+        df_merge1 = pd.concat([df_combo_c, Ne_corr], axis=1).reset_index(drop=True)
+        df_merge = pd.concat([df, df_merge1], axis=1).reset_index(drop=True)
+    elif df_combo is not None:
+        df_merge = pd.concat([df, df_combo_c], axis=1).reset_index(drop=True)
+    else:
+        df_merge = df
+
+    return df_merge
+    
+    ## Way to actually shift densimeter
+    
+    # This general model works for any pickel you load in. 
+def apply_and_save_vertical_shift_to_model(*, pickle_in_path, new_x, new_y, pickle_out_path=None):
+    """
+    Applies a vertical shift to a saved piecewise model based on new_x and new_y,
+    then saves the shifted model to a new .pkl file.
+
+    Parameters
+    ----------
+    pickle_in_path : str
+        Path to the original .pkl file (output from build_piecewise_poly_by_density).
+    new_x : array-like
+        Corrected splitting values (x).
+    new_y : array-like
+        Measured density values (y).
+    pickle_out_path : str, optional
+        Where to save the new model. If None, appends '_shifted.pkl' to the input path.
+
+    Returns
+    -------
+    shift : float
+        Vertical shift applied to the model.
+    """
+    import pickle
+    import numpy as np
+
+    # Load the model
+    with open(pickle_in_path, 'rb') as f:
+        model_data = pickle.load(f)
+
+    # Rebuild the base function
+    base_model = pf.load_piecewise_model(model_data)
+    f_vals = base_model(new_x)
+
+    # Calculate vertical shift
+    shift = np.nanmean(new_y - f_vals)
+
+    # Store the shift
+    model_data['vertical_shift'] = shift
+
+    # Save new .pkl
+    if pickle_out_path is None:
+        pickle_out_path = pickle_in_path.replace('.pkl', '_shifted.pkl')
+
+    with open(pickle_out_path, 'wb') as f:
+        pickle.dump(model_data, f)
+
+    return shift
+
+
+
+
+
+def apply_and_save_vertical_shift_to_ucb_densimeter(new_x, new_y):
+    """
+    Applies a vertical shift to a saved piecewise model based on new_x and new_y,
+    then saves the shifted model to a new .pkl file in the same directory.
+
+    Parameters
+    ----------
+    filename : str
+        Name of the original .pkl file (e.g., "smoothed_polyfit_June25_UCB.pkl").
+    new_x : array-like
+        Corrected splitting values (x).
+    new_y : array-like
+        Measured density values (y).
+    pickle_out_name : str, optional
+        Filename to save the new shifted model. If None, appends '_shifted.pkl' to the input name.
+
+    Returns
+    -------
+    shift : float
+        Vertical shift applied to the model.
+    """
+    
+    
+    
+        
+        
+
+    DiadFit_dir = Path(__file__).parent
+
+
+    with open(DiadFit_dir / "smoothed_polyfit_June25_UCB.pkl", 'rb') as f:
+        model_data = pickle.load(f)
+
+    base_model = load_piecewise_model(model_data)
+    f_vals = base_model(new_x)
+
+    shift = np.nanmean(new_y - f_vals)
+    model_data['vertical_shift'] = shift
+
+
+
+    return shift
+

DiadFit/error_propagation.py

@@ -884,7 +884,7 @@ def convert_co2_dens_press_depth(EOS='SW96', T_K=None,
     CO2_dens_gcm3=None,
     crust_dens_kgm3=None, output='kbar',
     g=9.81, model=None, XH2O=None, Hloss=True,
-    d1=None, d2=None, rho1=None, rho2=None, rho3=None,T_K_ambient=37+273.15 ):
+    d1=None, d2=None,d3=None, rho1=None, rho2=None, rho3=None, rho4=None, T_K_ambient=37+273.15 ):
 
     """ This function calculates pressure and depth based on input CO2 densities, 
     temperatures, and crustal density information from the user
@@ -921,12 +921,13 @@ def convert_co2_dens_press_depth(EOS='SW96', T_K=None,
 
                 if model is three-step:
                 If three step, must also define:
-                    d1: Depth to first transition in km
                     rho1: Density between surface and 1st transition
-                    d2: Depth to second transition in km (from surface)
+                    d1: Depth to first transition in km
                     rho2: Density between 1st and 2nd transition
-                    d3: Depth to third transition in km (from surface)
+                    d2: Depth to second transition in km (from surface)
                     rho3: Density between 2nd and 3rd transition depth.
+                    d3: Depth to third transition in km (from surface)
+                    rho4: Density between below d3
 
     Returns
     ---------------------
@@ -997,9 +998,11 @@ def convert_co2_dens_press_depth(EOS='SW96', T_K=None,
         P_kbar_calc=pf.calculate_entrapment_P_XH2O(XH2O=XH2O, CO2_dens_gcm3=CO2_dens_gcm3, T_K=T_K, T_K_ambient=T_K_ambient, fast_calcs=True, Hloss=Hloss )
         
         
-        Depth_km=convert_pressure_to_depth(P_kbar_calc,
+        Depth_km=convert_pressure_to_depth(P_kbar=P_kbar_calc,
                         crust_dens_kgm3=crust_dens_kgm3,     g=9.81, model=model,
-            d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3)
+            d1=d1, d2=d2, d3=d3, rho1=rho1, rho2=rho2, rho3=rho3, rho4=rho4)
+            
+
             
         if type(Depth_km) is float:
                 # Crustal density, using P=rho g H

DiadFit/ne_lines.py

@@ -1894,7 +1894,6 @@ def generate_Ne_corr_model(*, time, Ne_corr, N_poly=3, CI=0.67, bootstrap=False,
     
 from scipy.stats import t
 
-
 def calculate_Ne_corr_std_err_values(*, pickle_str, new_x, CI=0.67):
     # Load the model and the data from the pickle file
     with open(pickle_str, 'rb') as f:
@@ -1902,11 +1901,14 @@ def calculate_Ne_corr_std_err_values(*, pickle_str, new_x, CI=0.67):
 
     model = data['model']
     N_poly = model.order - 1
-    
+
     Pf = data['model']
     x = data['x']
     y = data['y']
 
+    # Convert new_x to plain numpy array
+    new_x_array = np.asarray(new_x)
+
     # Calculate the residuals
     residuals = y - Pf(x)
 
@@ -1916,27 +1918,29 @@ def calculate_Ne_corr_std_err_values(*, pickle_str, new_x, CI=0.67):
     # Calculate the standard errors for the new x values
     mean_x = np.mean(x)
     n = len(x)
-    standard_errors = residual_std * np.sqrt(1 + 1/n + (new_x - mean_x)**2 / np.sum((x - mean_x)**2))
+    standard_errors = residual_std * np.sqrt(1 + 1/n + (new_x_array - mean_x)**2 / np.sum((x - mean_x)**2))
 
     # Calculate the degrees of freedom
-    df = len(x) - (N_poly + 1)
+    df_dof = len(x) - (N_poly + 1)
 
     # Calculate the t value for the given confidence level
-    t_value = t.ppf((1 + CI) / 2, df)
+    t_value = t.ppf((1 + CI) / 2, df_dof)
 
     # Calculate the prediction intervals
-    preferred_values = Pf(new_x)
+    preferred_values = Pf(new_x_array)
     lower_values = preferred_values - t_value * standard_errors
     upper_values = preferred_values + t_value * standard_errors
 
-    df=pd.DataFrame(data={
-        'time': new_x,
+    df_out = pd.DataFrame(data={
+        'time': new_x_array,
         'preferred_values': preferred_values,
         'lower_values': lower_values,
         'upper_values': upper_values
     })
 
-    return df
+    return df_out
+
+
 
 
 

DiadFit-1.0.10.dist-info/LICENSE.txt

@@ -0,0 +1,16 @@
+LICENSE
+
+Copyright (c) [2025] [Penny Wieser]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+Special Clause on GUI Usage
+
+Use of DiadFit in graphical user interfaces (GUIs), including but not limited to applications that provide point-and-click access to DiadFit’s functions, requires prior written permission from the author.
+
+This requirement exists because of a broader issue in the geoscience community: tools that wrap or interface with core scientific software often receive the bulk of citations, while foundational packages like DiadFit go unrecognized—particularly when journals impose citation limits. DiadFit represents a significant and ongoing labor investment. Responsible citation and acknowledgment are necessary to support its continued development and maintenance.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

{DiadFit-1.0.9.dist-info → DiadFit-1.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DiadFit
-Version: 1.0.9
+Version: 1.0.10
 Summary: DiadFit
 Home-page: https://github.com/PennyWieser/DiadFit
 Author: Penny Wieser

{DiadFit-1.0.9.dist-info → DiadFit-1.0.10.dist-info}/RECORD

@@ -29,22 +29,24 @@ DiadFit/Mediumrho_polyfit_data_CCMR.pkl,sha256=U6ODSdurqS0-lynm1MG1zktg8NuhYRbrY
 DiadFit/Mediumrho_polyfit_data_CMASS.pkl,sha256=SBy1pIdqCAF9UtB9FLNTuD0-tFyD7swwJppdE2U_FsY,1557
 DiadFit/Psensor.py,sha256=C2xSlgxhUJIKIBDvUp02QaYRs5QsIqjGGRMP25ZLRZ0,10435
 DiadFit/__init__.py,sha256=F-HjhCYKL_U8PfiH8tZ9DUCkxPvo6lAslJS4fyvxkbY,1148
-DiadFit/_version.py,sha256=8wkWdIefAjvOQecKda3-TYv9_XiCz7EIQMvxj1kOrJA,295
+DiadFit/_version.py,sha256=yrzFCh_DgcJ9iS_fo4-jCpQ0dTsU1x004zEAZPOJWu4,296
 DiadFit/argon_lines.py,sha256=vtzsuDdEgrAmEF9xwpejpFqKV9hKPS1JUYhIl4AfXZ0,7675
 DiadFit/cosmicray_filter.py,sha256=a45x2_nmpi9Qcjc_L39UA9JOd1NMorIjtTRGnCdG3MU,23634
 DiadFit/densimeter_fitting.py,sha256=AV5jWHSuIuN-e61chwMiTETa26pQo5drEGorYTkceHo,8308
-DiadFit/densimeters.py,sha256=J4DnQgavhkDKOaBTQqqShepZVeH5jxJiT1FmebmLY88,55282
+DiadFit/densimeters.py,sha256=1eT6XVYtRPbY4WmEgIvbvEYdDkJTvFlIjoqhypdpDKk,76511
 DiadFit/density_depth_crustal_profiles.py,sha256=Vvtw3-_xuWIYEuhuDzXstkprluXyBkUcdm9iP7qBwyQ,19754
 DiadFit/diads.py,sha256=gwHWTquJeoJaBYEYjJcJct38j6Bi-GUUsFCPsFgCFzU,179483
-DiadFit/error_propagation.py,sha256=ZN9EspONh_vUGxBHxxWNkYskKqFMRvJMNr2h2RXv-54,50624
+DiadFit/error_propagation.py,sha256=Evka2vsHQmgekO1xft-AkjxvkMdwAVawNVbWSe7SZIQ,50734
 DiadFit/importing_data_files.py,sha256=j7cSEPZ6iKmYnSqYEIcCl7YNdqqkCD56W-4V9T2oWOE,52010
 DiadFit/lookup_table.csv,sha256=Hs1tmSQ9ArTUDv3ymEXbvnLlPBxYUP0P51dz7xAKk-Q,2946857
 DiadFit/lookup_table_noneg.csv,sha256=HelvewKbBy4cqT2GAqsMo-1ps1lBYqZ-8hCJZWPGfhI,3330249
 DiadFit/molar_gas_proportions.py,sha256=3zc5t037L11w_hCYJqV4Xp4NwVCmGb3gMp1McAhV0TM,9315
-DiadFit/ne_lines.py,sha256=KR1s33pZB_O8e3irtDLdBpepGwUjxWudjJNyHyXqfbg,63980
+DiadFit/ne_lines.py,sha256=kY_6ThigSc21ONyo38yq1gBhzlyUPYcfbYC50nIoiRs,64091
 DiadFit/relaxfi_PW.py,sha256=vXXW9JjEBRf0UR9p-DJLx8j4Z2ePpUDweoAok-2nMJ0,32119
 DiadFit/relaxifi.py,sha256=DSHAUP0tnkiMrHQgQPBK-9P3cWYmegURKzYOUgdAlos,38569
-DiadFit-1.0.9.dist-info/METADATA,sha256=8cAHxsD398JkFantbqsbVF1BMvHOes3KgsTkvCBjRWE,1171
-DiadFit-1.0.9.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-DiadFit-1.0.9.dist-info/top_level.txt,sha256=yZC6OFLVznaFA5kcPlFPkvhKotcVd-YO4bKxZZw3LQE,8
-DiadFit-1.0.9.dist-info/RECORD,,
+DiadFit/smoothed_polyfit_June25_UCB.pkl,sha256=I_AHj8uJVv1lPfir6QZa-EmOzSp8yDAWUZH2ZTE-0KI,2596
+DiadFit-1.0.10.dist-info/LICENSE.txt,sha256=wM112Xn2cOj94pg0LUBgB-7Vs2y8KZ4bzrhIK-R72WE,1707
+DiadFit-1.0.10.dist-info/METADATA,sha256=oA2cVHNgcUtEC8uwK875WtNcdgXHquyZssF0az4591o,1172
+DiadFit-1.0.10.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+DiadFit-1.0.10.dist-info/top_level.txt,sha256=yZC6OFLVznaFA5kcPlFPkvhKotcVd-YO4bKxZZw3LQE,8
+DiadFit-1.0.10.dist-info/RECORD,,