DiadFit 1.0.8__tar.gz → 1.0.10__tar.gz

DiadFit-1.0.10/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.8 → DiadFit-1.0.10}/PKG-INFO

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

{DiadFit-1.0.8 → DiadFit-1.0.10}/src/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.8'
+__version__ = '1.0.10'

{DiadFit-1.0.8 → DiadFit-1.0.10}/src/DiadFit/densimeter_fitting.py

@@ -15,6 +15,7 @@ from scipy import stats
 
 encode="ISO-8859-1"
 
+## Files are fit using the folder UCB_cali_fitting_1117_1447
 
 def calculate_generic_std_err_values(*, pickle_str, new_x, CI=0.67):
 

{DiadFit-1.0.8 → DiadFit-1.0.10}/src/DiadFit/densimeters.py

@@ -994,7 +994,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     corrected_split: pd.Series
         Corrected splitting  (cm-1)  
         
-    Split_err: float, int
+    split_err: float, int
         Error on corrected splitting
 
     temp: str
@@ -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
+