diff --git a/.virtual_documents/notebooks/genericmodelimplementation_6state.ipynb b/.virtual_documents/notebooks/genericmodelimplementation_6state.ipynb new file mode 100644 index 0000000..f1b9da3 --- /dev/null +++ b/.virtual_documents/notebooks/genericmodelimplementation_6state.ipynb @@ -0,0 +1,586 @@ +%matplotlib inline +from matplotlib import pyplot as plt +import numpy as np +import pandas as pd +import dataprob +import copy +import linkage + + +### Load Experimental Data +cell_vol = 201.3 + +## EDTA --> Protein + Ca +prot1 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240913\3p5mMEDTAto50uMhA4HIGHRES.csv", + cell_contents={"CT":500e-6, "AT":25e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +prot1.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +prot2 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240913\3p5mMEDTAto50uMhA4SUPERDUPERRES.csv", + cell_contents={"CT":500e-6, "AT":25e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +prot2.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +prot3 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240823\3mMEDTAto50uMhA4.csv", + cell_contents={"CT":500e-6, "AT":25e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +prot3.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +prot4 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240822\3mMEDTAto50uMhA4.csv", + cell_contents={"CT":500e-6, "AT":25e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +prot4.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +prot5 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240822\3mMEDTAto50uMhA42.csv", + cell_contents={"CT":500e-6, "AT":25e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +prot5.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +prot6 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240822\3mMEDTAto50uMhA43.csv", + cell_contents={"CT":500e-6, "AT":25e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +prot6.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## Ca -> EDTA + Protein + +reprot1 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\500uMCato50uMEDTA50uMhA4.csv", + cell_contents={"ET":50e-6, "AT":25e-6}, + syringe_contents={"CT":500e-6}, + cell_volume=cell_vol, + conc_to_float="ET") +reprot1.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +reprot2 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\1mMCato50uMEDTA50uMhA4.csv", + cell_contents={"ET":50e-6, "AT":25e-6}, + syringe_contents={"CT":1e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +reprot2.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +## EDTA --> Buffer + +blank1 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240806\4mMEDTAinto0uMCa2.csv", + cell_contents={"CT":0}, + syringe_contents={"ET":4e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +blank1.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +blank2 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240806\4mMEDTAinto0uMCa3.csv", + cell_contents={"CT":0}, + syringe_contents={"ET":4e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +blank2.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## Ca --> Buffer + +blank3 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\1mMCatobuffer.csv", + cell_contents={}, + syringe_contents={"CT":1e-3}, + cell_volume=cell_vol, + conc_to_float="CT") +blank3.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +blank4 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\1mMCatobuffer2.csv", + cell_contents={}, + syringe_contents={"CT":1e-3}, + cell_volume=cell_vol, + conc_to_float="CT") +blank4.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## Ca --> EDTA + +caedta1 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\500uMCato50uMEDTA.csv", + cell_contents={"ET":50e-6}, + syringe_contents={"CT":500e-6}, + cell_volume=cell_vol, + conc_to_float="ET") +caedta1.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## EDTA --> Ca + +edtaca1 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20241001\3mMEDTAto500uMCa.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca1.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +edtaca2 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20241001\3p5mMEDTAto500uMCaCl2HHR.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca2.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +edtaca3 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240915\3p5mMEDTAto500uMCaCl2lowres.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca3.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + + +edtaca4 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240913\3p5mMEDTAto500uMCaLOWRES.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca4.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +edtaca5 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240912\3mMEDTAto500uMCaCl2.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca5.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +edtaca6 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240912\3mMEDTAto500uMCaCl2_2.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca6.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +edtaca7 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240912\3mMEDTAto500uMCaCl2_3.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca7.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## CD Experiments + +# cd1 = linkage.experiment.Experiment(r"", +# cell_contents={"CT":500e-6, "AT":25e-6}, +# syringe_contents={"ET":2e-3}, +# cell_volume=cell_vol, +# conc_to_float="ET") + + + + + +#### Create model instance +#Full Lists +blank_list = [blank1, blank3] +edtaca_list = [edtaca1] +prot_list = [prot1] + +#Combine experiment types into one list +expt_list = blank_list + edtaca_list + prot_list + + +# Read the model specification from file +spec_file_path = r"C:\Users\willi\linkage\src\linkage\model_specs\SixStateEDTA.txt" + +# Read spec +with open(spec_file_path, 'r') as f: + model_spec = f.read() + +# Create GlobalModel with spec +gm = linkage.GlobalModel( + model_name="GenericBindingModel", + model_spec=model_spec, + expt_list=expt_list +) + +#Setup dataprob +f = dataprob.setup(gm.model_normalized, + method="ml", + vector_first_arg=True, + fit_parameters=gm.parameter_names) + + + +f.param_df + + +# Create a dictionary to hold the complete configuration for each parameter. +# This makes it easy to see all settings for a given parameter in one place. +param_configs = { + + # --- Equilibrium Constants (lnK) --- + # Since A is favored over I, KI = [I]/[A] << 1, so ln(KI) must be negative. + "KI": {"guess": -4.6, "lower_bound": -10, "upper_bound": -1, "fixed": False}, + + # High-affinity Ca++ binding sites (e.g., K from ~1e3 to ~1e9 M^-1) + "K1": {"guess": 15.0, "lower_bound": 7, "upper_bound": 21, "fixed": False}, + "K2": {"guess": 15.0, "lower_bound": 7, "upper_bound": 21, "fixed": False}, + + # Low-affinity Ca++ binding sites (e.g., K from ~1e2 to ~1e5 M^-1) + "K3": {"guess": 9.0, "lower_bound": 5, "upper_bound": 12, "fixed": False}, + "K4": {"guess": 9.0, "lower_bound": 5, "upper_bound": 12, "fixed": False}, + + # EDTA binding constant (fixed from prior knowledge) + "KE": {"guess": 16.18,"lower_bound": 16.16,"upper_bound": 16.20,"fixed": True}, + + # --- Enthalpies (in ucal/mol) --- + # Assumed isoenthalpic for the inactive->active transition + "dH_I": {"guess": 0, "fixed": True}, + + # Binding dH should be within a physical range (~ +/- 20 kcal/mol -> +/- 20e6 ucal/mol) + "dH_1": {"guess": -5.0e6, "lower_bound": -20.0e6, "upper_bound": 20.0e6}, + "dH_2": {"guess": -5.0e6, "lower_bound": -20.0e6, "upper_bound": 20.0e6}, + "dH_3": {"guess": -2.0e6, "lower_bound": -20.0e6, "upper_bound": 20.0e6}, + "dH_4": {"guess": -2.0e6, "lower_bound": -20.0e6, "upper_bound": 20.0e6}, + + # EDTA binding enthalpy (fixed from prior knowledge) + "dH_E": {"guess": -10902, "lower_bound": -11000, "upper_bound": -10800, "fixed": True}, + + # --- Nuisance Parameters: Dilution (in ucal/mol) --- + "nuisance_dil_CT": {"guess": -400, "lower_bound": -1000, "upper_bound": 1000, "fixed": False}, + "nuisance_dil_ET": {"guess": 30, "lower_bound": -1000, "upper_bound": 1000, "fixed": False}, +} + +# Apply the configurations to the parameter DataFrame +for param_name, settings in param_configs.items(): + if param_name in f.param_df.index: + # Use .get() to avoid errors if a key (like 'fixed') is not specified + for key, value in settings.items(): + f.param_df.loc[param_name, key] = value + else: + print(f"Warning: Parameter '{param_name}' from config not in model.") + +# --- Nuisance Parameters: Experimental Fudge Factors --- +# These concentration multipliers should be close to 1.0 +fudge_params = [name for name in f.param_df.index if 'nuisance_expt' in name] +for param_name in fudge_params: + f.param_df.loc[param_name, 'guess'] = 1.0 + f.param_df.loc[param_name, 'fixed'] = False # Usually better to let these float + f.param_df.loc[param_name, 'lower_bound'] = 0.8 + f.param_df.loc[param_name, 'upper_bound'] = 1.2 + +# Display the final, configured DataFrame to verify +print("--- Final Parameter Configuration ---") +print(f.param_df) + + +f.param_df + + +### ML FITTER FUNCTION CALL (Requires method="ml" in the dataprob fitter setup) + + +f.fit( + y_obs=gm.y_obs_normalized, + y_std=gm.y_std_normalized, + + # --- Core Arguments for the Optimizer --- + method='trf', # Trust Region Reflective is good for bounded problems. + + # --- Jacobian and Step Size --- + jac='3-point', # More accurate but slower numerical Jacobian. + diff_step=1e-7, # Specify a relative step size for finite differences. + # Helps with parameters of different scales. + + # --- Tolerances --- + # Loosen ftol/gtol slightly to handle flat regions, keep xtol tight. + ftol=1e-9, # Termination by change in cost function. + xtol=1e-6, # Termination by change in parameters. + gtol=1e-6, # Termination by norm of the gradient. + + # --- Scaling and Robustness --- + x_scale='jac', # Crucial for problems where parameters have very different + # magnitudes. Let the Jacobian estimate the scales. + loss='linear', # Standard least-squares. Change to 'soft_l1' if you + # suspect outliers in your data. + + # --- Number of function evaluations --- + max_nfev=40, + + # --- Verbosity --- + verbose=2 # Keep this at 2 to see the step-by-step progress + # of the optimization. +) + + +### MCMC FITTER FUNCTION CALL (Requires method="mcmc" in the dataprob fitter setup) + + +f.fit( + y_obs=gm.y_obs_normalized, + y_std=gm.y_std_normalized, + + # Number of walkers to explore parameter space. Should be <2 times the number of fit parameters. + num_walkers=100, + + # Initial number of steps for each walker before checking convergence. + num_steps=500, + + # Use a preliminary ML fit to find a good starting position for the walkers. + use_ml_guess=True, + + # The sampler will automatically try to extend the run this many times to meet convergence criteria. + max_convergence_cycles=5, + + # Fraction of initial steps to discard from each walker for the final analysis. + burn_in=0.2, +) + +# Print the results summary and final parameter estimates +print(f) + + +pd.set_option('display.float_format', lambda x: '%.6f' % x) +f.fit_df + + + + + + + + +style = {"s":50, + "facecolor":"none", + "edgecolor":"black"} +err_style = {"lw":0, + "elinewidth":1, + "capsize":2} + +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +edtaca_length = len(edtaca_list) +prot_length = len(prot_list) +blank_length = len(blank_list) + +color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length] + +fig, ax = plt.subplots(1,figsize=(6,6)) + +out_df = gm.as_df.copy() +y_calc = gm.model(np.array(f.fit_df["estimate"])) + +for i in np.unique(out_df.expt_id): + + style["edgecolor"] = color_order[i] + err_style["color"] = color_order[i] + + mask = out_df["expt_id"] == i + this_df = out_df.loc[mask,:] + + + x_values = np.cumsum(this_df["injection"]) + y_values = np.array(this_df["y_obs"]) + y_err = np.array(this_df["y_std"])/np.mean(this_df["injection"]) + this_y_calc = y_calc[mask]/this_df["injection"] + + y_values = y_values/this_df["injection"] + + ax.scatter(x_values,y_values,**style) + ax.errorbar(x=x_values, + y=y_values, + #yerr=y_err, + **err_style) + + ax.plot(x_values,this_y_calc,'-',color=color_order[i]) + +ax.set_ylim((-100,10)) + +plt.xlabel("injection") +plt.ylabel("heat") + + +style = {"s":50, + "facecolor":"none", + "edgecolor":"black"} +err_style = {"lw":0, + "elinewidth":1, + "capsize":2} + +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +fig, ax = plt.subplots(1,figsize=(6,6)) + +out_df = gm.as_df.copy() +y_calc = gm.model(np.array(f.fit_df["estimate"])) + +for i in np.unique(out_df.expt_id): + + style["edgecolor"] = "blue" + err_style["color"] = "red" + + mask = out_df["expt_id"] == i + this_df = out_df.loc[mask,:] + + + x_values = np.cumsum(this_df["injection"]) + y_values = np.array(this_df["y_obs"]) + y_err = np.array(this_df["y_std"])/np.mean(this_df["injection"]) + this_y_calc = y_calc[mask]/this_df["injection"] + + y_values = y_values/this_df["injection"] + + ax.scatter(x_values,y_values,**style) + ax.errorbar(x=x_values, + y=y_values, + #yerr=y_err, + **err_style) + + ax.plot(x_values,this_y_calc,'-',color="red") + +ax.set_ylim((-100,10)) + +plt.xlabel("injection") +plt.ylabel("heat") + + +# Print column names for one of each type of experiment +print("Blank experiment columns:") +print(blank_list[0].expt_concs.columns) +print("\nEDTA-Ca experiment columns:") +print(edtaca_list[0].expt_concs.columns) +print("\nProtein experiment columns:") +print(prot_list[0].expt_concs.columns) + +# Check data structure +print("\nSample of concentration data:") +print(prot_list[0].expt_concs.head()) + + +import numpy as np +import matplotlib.pyplot as plt + +# Plot settings +style = {"s": 50, "facecolor": "none"} +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +# Get fitted parameters and calculate theoretical heats +params = np.array(f.fit_df["estimate"]) +y_calc = gm.model(params) + +fig, ax = plt.subplots(1, figsize=(8,6)) + +# Get overall y range from experimental data to set limits +y_min = gm.as_df["y_obs"].min() +y_max = gm.as_df["y_obs"].max() +y_range = y_max - y_min +y_limits = [y_min - 15*y_range, y_max + 15*y_range] + +# Plot each experiment +for i in np.unique(gm.as_df.expt_id): + style["edgecolor"] = color_order[i] + + # Get data for this experiment using gm.as_df + mask = gm.as_df.expt_id == i + this_df = gm.as_df.loc[mask,:] + + # Get theoretical heats for this experiment + heats = y_calc[mask] + # Calculate injection-to-injection differences + heat_diffs = np.diff(heats, prepend=heats[0]) + + # Get experimental points + x_values = np.cumsum(this_df["injection"]) + y_values = this_df["y_obs"] + + # Plot experimental points + ax.scatter(x_values, y_values, + **style, + label=f'Expt {i} (data)') + + # Plot theoretical curve using differences + ax.plot(x_values, heat_diffs, '-', + color=color_order[i], + label=f'Expt {i} (fit)') + +ax.set_xlabel('Cumulative Injection') +ax.set_ylabel('Heat per injection (μcal)') +ax.set_ylim(y_limits) +ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left') +plt.tight_layout() +plt.show() + + +fig = dataprob.plot_corner(f) + + +fig = dataprob.plot_summary(f) + + + +# No error consideration +style = { + "s": 50, + "facecolor": "none", + "edgecolor": "black" +} + +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +edtaca_length = len(edtaca_list) +prot_length = len(prot_list) +blank_length = len(blank_list) +color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length] + +fig, ax = plt.subplots(1, figsize=(6,6)) +out_df = gm.as_df.copy() +y_calc = gm.model(np.array(f.fit_df["estimate"])) + +for i in np.unique(out_df.expt_id): + style["edgecolor"] = color_order[i] + mask = out_df["expt_id"] == i + this_df = out_df.loc[mask,:] + + x_values = np.cumsum(this_df["injection"]) + y_values = np.array(this_df["y_obs"]) + this_y_calc = y_calc[mask]/this_df["injection"] + y_values = y_values/this_df["injection"] + + ax.scatter(x_values, y_values, **style) + ax.plot(x_values, this_y_calc, '-', color=color_order[i]) + +plt.xlabel("injection") +plt.ylabel("heat") +f.fit_df + + + diff --git a/.virtual_documents/notebooks/genericmodelimplementation_CaEDTA.ipynb b/.virtual_documents/notebooks/genericmodelimplementation_CaEDTA.ipynb new file mode 100644 index 0000000..a7a597f --- /dev/null +++ b/.virtual_documents/notebooks/genericmodelimplementation_CaEDTA.ipynb @@ -0,0 +1,385 @@ +%matplotlib inline +from matplotlib import pyplot as plt +import numpy as np +import pandas as pd +import dataprob +import copy +import linkage + + +#### Load Experimental Data + +## EDTA --> Buffer + +cell_vol = 201.3 +sd = 0.1 + +## EDTA --> Buffer + +blank1 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240806\4mMEDTAinto0uMCa2.csv", + cell_contents={}, + syringe_contents={"ET":4e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +blank1.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +blank2 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240806\4mMEDTAinto0uMCa3.csv", + cell_contents={}, + syringe_contents={"ET":4e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +blank2.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## Ca --> Buffer + +blank3 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\1mMCatobuffer.csv", + cell_contents={}, + syringe_contents={"CT":1e-3}, + cell_volume=cell_vol, + conc_to_float="CT") +blank3.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +blank4 = linkage.experiment.Experiment(r"S:\Harmslab\ITC2\20241220\1mMCatobuffer2.csv", + cell_contents={}, + syringe_contents={"CT":1e-3}, + cell_volume=cell_vol, + conc_to_float="CT") +blank4.define_itc_observable(obs_column="heat", + obs_std="heat_stdev") + +## EDTA --> Ca + +edtaca1 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20241001\3mMEDTAto500uMCa.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca1.define_itc_observable(obs_column="heat", + obs_std=sd) + + +edtaca2 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20241001\3p5mMEDTAto500uMCaCl2HHR.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca2.define_itc_observable(obs_column="heat", + obs_std=sd) + + +edtaca3 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240915\3p5mMEDTAto500uMCaCl2lowres.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca3.define_itc_observable(obs_column="heat", + obs_std=sd) + + +edtaca4 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240913\3p5mMEDTAto500uMCaLOWRES.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3.5e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca4.define_itc_observable(obs_column="heat", + obs_std=sd) + +edtaca5 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240912\3mMEDTAto500uMCaCl2.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca5.define_itc_observable(obs_column="heat", + obs_std=sd) + +edtaca6 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240912\3mMEDTAto500uMCaCl2_2.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca6.define_itc_observable(obs_column="heat", + obs_std=sd) + +edtaca7 = linkage.experiment.Experiment(r"C:\Users\willi\linkage\notebooks\data\20240912\3mMEDTAto500uMCaCl2_3.csv", + cell_contents={"CT":500e-6}, + syringe_contents={"ET":3e-3}, + cell_volume=cell_vol, + conc_to_float="ET") +edtaca7.define_itc_observable(obs_column="heat", + obs_std=sd) + + + + + +#### Create model instance +#Full Lists +blank_list = [blank1, blank2, blank3, blank4] +edtaca_list = [edtaca1, edtaca2, edtaca3, edtaca4, edtaca5, edtaca6, edtaca7] + + +#Combine experiment types into one list +expt_list = blank_list + edtaca_list + + +# Read the model specification from file +spec_file_path = r"C:\Users\willi\linkage\src\linkage\model_specs\CaEDTA.txt" + +# Read spec +with open(spec_file_path, 'r') as f: + model_spec = f.read() + +# Create GlobalModel with spec +gm = linkage.GlobalModel( + model_name="GenericBindingModel", + model_spec=model_spec, + expt_list=expt_list +) + +#Setup dataprob +f = dataprob.setup(gm.model_normalized, + method="ml", + vector_first_arg=True, + fit_parameters=gm.parameter_names) + + + + +f.param_df + + +param_configs = { + "KE": { + "guess": 24.0, # ln(K) for a K of ~2.6e10 M^-1 + "lower_bound": 20, # K ~ 5e8 M^-1 + "upper_bound": 28, # K ~ 1.5e12 M^-1 + }, + "dH_E": { + "guess": -4.5e6, # dH of ~ -4.5 kcal/mol + "lower_bound": -10.0e6, # -10 kcal/mol + "upper_bound": -1.0e6, # -1 kcal/mol + }, + "nuisance_dil_CT": { + "guess": 0.0, + "lower_bound": -50000, + "upper_bound": 50000, + }, + "nuisance_dil_ET": { + "guess": 0.0, + "lower_bound": -50000, + "upper_bound": 50000, + }, +} + +for param_name, settings in param_configs.items(): + if param_name in f.param_df.index: + for key, value in settings.items(): + f.param_df.loc[param_name, key] = value + +fudge_params = [name for name in f.param_df.index if 'nuisance_expt' in name] +for param_name in fudge_params: + f.param_df.loc[param_name, 'guess'] = 1.1 + f.param_df.loc[param_name, 'fixed'] = True + f.param_df.loc[param_name, 'lower_bound'] = -2 + f.param_df.loc[param_name, 'upper_bound'] = 2 + +print(f.param_df) + + +f.param_df + + +f.fit( + y_obs=gm.y_obs_normalized, + y_std=gm.y_std_normalized, + method='trf', + jac='3-point', + ftol=1e-9, + xtol=1e-9, + gtol=1e-9, + loss='arctan', + f_scale=0.1, + x_scale='jac', + max_nfev=1000, + verbose=2 +) + + +pd.set_option('display.float_format', lambda x: '%.6f' % x) +f.fit_df + + + + + + + + +style = {"s":50, + "facecolor":"none", + "edgecolor":"black"} +err_style = {"lw":0, + "elinewidth":1, + "capsize":2} + +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +edtaca_length = len(edtaca_list) +blank_length = len(blank_list) + +color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + +fig, ax = plt.subplots(1,figsize=(6,6)) + +out_df = gm.as_df.copy() +y_calc = gm.model(np.array(f.fit_df["estimate"])) + +for i in np.unique(out_df.expt_id): + + style["edgecolor"] = color_order[i] + err_style["color"] = color_order[i] + + mask = out_df["expt_id"] == i + this_df = out_df.loc[mask,:] + + + x_values = np.cumsum(this_df["injection"]) + y_values = np.array(this_df["y_obs"]) + y_err = np.array(this_df["y_std"])/np.mean(this_df["injection"]) + this_y_calc = y_calc[mask]/this_df["injection"] + + y_values = y_values/this_df["injection"] + + ax.scatter(x_values,y_values,**style) + ax.errorbar(x=x_values, + y=y_values, + #yerr=y_err, + **err_style) + + ax.plot(x_values,this_y_calc,'-',color=color_order[i]) + +ax.set_ylim((-100,10)) + +plt.xlabel("injection") +plt.ylabel("heat") + + +# Print column names for one of each type of experiment +print("Blank experiment columns:") +print(blank_list[0].expt_concs.columns) +print("\nEDTA-Ca experiment columns:") +print(edtaca_list[0].expt_concs.columns) + + +# Check data structure +print("\nSample of concentration data:") +print(edtaca_list[0].expt_concs.head()) + + +import numpy as np +import matplotlib.pyplot as plt + +# Plot settings +style = {"s": 50, "facecolor": "none"} +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +# Get fitted parameters and calculate theoretical heats +params = np.array(f.fit_df["estimate"]) +y_calc = gm.model(params) + +fig, ax = plt.subplots(1, figsize=(8,6)) + +# Get overall y range from experimental data to set limits +y_min = gm.as_df["y_obs"].min() +y_max = gm.as_df["y_obs"].max() +y_range = y_max - y_min +y_limits = [y_min - 15*y_range, y_max + 15*y_range] + +# Plot each experiment +for i in np.unique(gm.as_df.expt_id): + style["edgecolor"] = color_order[i] + + # Get data for this experiment using gm.as_df + mask = gm.as_df.expt_id == i + this_df = gm.as_df.loc[mask,:] + + # Get theoretical heats for this experiment + heats = y_calc[mask] + # Calculate injection-to-injection differences + heat_diffs = np.diff(heats, prepend=heats[0]) + + # Get experimental points + x_values = np.cumsum(this_df["injection"]) + y_values = this_df["y_obs"] + + # Plot experimental points + ax.scatter(x_values, y_values, + **style, + label=f'Expt {i} (data)') + + # Plot theoretical curve using differences + ax.plot(x_values, heat_diffs, '-', + color=color_order[i], + label=f'Expt {i} (fit)') + +ax.set_xlabel('Cumulative Injection') +ax.set_ylabel('Heat per injection (μcal)') +ax.set_ylim(y_limits) +ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left') +plt.tight_layout() +plt.show() + + +fig = dataprob.plot_corner(f) + + +fig = dataprob.plot_summary(f) + + + +# No error consideration +style = { + "s": 50, + "facecolor": "none", + "edgecolor": "black" +} + +orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] +purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033'] +green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00'] + +edtaca_length = len(edtaca_list) +prot_length = len(prot_list) +blank_length = len(blank_list) +color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length] + +fig, ax = plt.subplots(1, figsize=(6,6)) +out_df = gm.as_df.copy() +y_calc = gm.model(np.array(f.fit_df["estimate"])) + +for i in np.unique(out_df.expt_id): + style["edgecolor"] = color_order[i] + mask = out_df["expt_id"] == i + this_df = out_df.loc[mask,:] + + x_values = np.cumsum(this_df["injection"]) + y_values = np.array(this_df["y_obs"]) + this_y_calc = y_calc[mask]/this_df["injection"] + y_values = y_values/this_df["injection"] + + ax.scatter(x_values, y_values, **style) + ax.plot(x_values, this_y_calc, '-', color=color_order[i]) + +plt.xlabel("injection") +plt.ylabel("heat") +f.fit_df + + + diff --git a/notebooks/JascoCDWorkflow.ipynb b/notebooks/JascoCDWorkflow.ipynb new file mode 100644 index 0000000..e78a9d8 --- /dev/null +++ b/notebooks/JascoCDWorkflow.ipynb @@ -0,0 +1,104 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "e96721ef-6566-499f-9b54-4b2ee0a4a882", + "metadata": {}, + "outputs": [], + "source": [ + "### Jasco CD output processing\n", + "### One stop shop (WIP)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d2f2209-edc7-4ada-95c7-a2dd2366b79c", + "metadata": {}, + "outputs": [], + "source": [ + "### Imports\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3ea9707-2d61-4b89-893b-8faf267f7fe4", + "metadata": {}, + "outputs": [], + "source": [ + "### Global Vars/Params\n", + "\n", + "data = r\"\"\n", + "signals = [\"farCD\", \"nearCD\", \"phe\", \"tyr\"]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0fe1afbd-2364-4bc8-a6ba-ebf905ddbe53", + "metadata": {}, + "outputs": [], + "source": [ + "### Function: Baseline Corrrection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7021eb32-18e4-4b83-b32f-329edda1fc1f", + "metadata": {}, + "outputs": [], + "source": [ + "### Function: LEM" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fc4fb9d-ff1a-40b0-8d19-4f392222e0bb", + "metadata": {}, + "outputs": [], + "source": [ + "for signal in signals:\n", + " # Do baseline correction\n", + " # Do " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "889a7ec2-2bff-4b3f-8425-428d6611e581", + "metadata": {}, + "outputs": [], + "source": [ + "### Statistical Summary\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/baselinetest.ipynb b/notebooks/baselinetest.ipynb new file mode 100644 index 0000000..677e1dd --- /dev/null +++ b/notebooks/baselinetest.ipynb @@ -0,0 +1,298 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "992865fb-2017-494e-8c95-8d329adafa53", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "%matplotlib inline\n", + "import numpy as np\n", + "import numpy.polynomial.polynomial as poly\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import os\n", + "from pathlib import Path\n", + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2ea03881-4828-4d78-a544-c822bae242d3", + "metadata": {}, + "outputs": [], + "source": [ + "### Baseline Corrector and Transition Range Fitting\n", + "\n", + "### General Functions\n", + "def simple_scaler(y):\n", + " \"\"\"\n", + " Simple min/max scaling to range 0-1\n", + " \"\"\"\n", + " y_min = np.min(y)\n", + " y_max = np.max(y)\n", + " return (y - y_min)/(y_max - y_min)\n", + "\n", + "def calculate_free_calcium(edta_ratio, total_ca=500e-6, ln_kf=10.65):\n", + " \"\"\"\n", + " Calculate free calcium concentration given EDTA:Ca ratio\n", + " edta_ratio: [EDTA]/[Ca] ratio\n", + " total_ca: total calcium concentration (M)\n", + " ln_kf: natural log of formation constant for EDTA-Ca complex\n", + " Returns: free calcium concentration (M)\n", + " \"\"\"\n", + " Kf = np.exp(ln_kf) \n", + " total_edta = edta_ratio * total_ca\n", + " \n", + " a = Kf\n", + " b = (Kf * total_edta - Kf * total_ca + 1)\n", + " c = -total_ca\n", + " \n", + " free_ca = (-b + np.sqrt(b**2 - 4*a*c)) / (2*a)\n", + " return free_ca\n", + "\n", + "def hill_equation(x, K, n, y_min):\n", + " \"\"\"\n", + " Hill equation for calcium binding with baseline offset\n", + " x: free [Ca²⁺] (M)\n", + " K: dissociation constant (M)\n", + " n: Hill coefficient\n", + " y_min: baseline offset\n", + " \"\"\"\n", + " return y_min + (1-y_min) * (x**n / (K**n + x**n))\n", + "\n", + "def baseline_corrector(filepath, x_col, y_col, left_start, left_end, right_start, right_end):\n", + " \"\"\"\n", + " Transform data using baseline correction and scaling, using explicit boundary points\n", + " for baseline fits. Handles file operations internally.\n", + " \n", + " Parameters:\n", + " -----------\n", + " filepath : str\n", + " Path to CSV file containing data\n", + " x_col : str\n", + " Name of x-axis column in CSV\n", + " y_col : str\n", + " Name of y-axis column in CSV\n", + " left_start : int\n", + " Starting index for left baseline region\n", + " left_end : int\n", + " Ending index for left baseline region\n", + " right_start : int\n", + " Starting index for right baseline region\n", + " right_end : int\n", + " Ending index for right baseline region\n", + " \n", + " Returns:\n", + " --------\n", + " tuple containing:\n", + " corrected_data : array\n", + " Baseline corrected and scaled data\n", + " signal_name : str\n", + " Name of the signal being processed\n", + " fig : matplotlib figure\n", + " Figure handle for the visualization plot\n", + " df_output : DataFrame\n", + " DataFrame containing x column and corrected signal\n", + " file_paths : dict\n", + " Dictionary containing output file paths\n", + " parameters: dict\n", + " Dictionary containing the baseline parameters used\n", + " \"\"\"\n", + " # Read data\n", + " try:\n", + " df = pd.read_csv(filepath)\n", + " except Exception as e:\n", + " raise Exception(f\"Error reading {filepath}: {str(e)}\")\n", + " \n", + " # Extract x and y data\n", + " if x_col not in df.columns or y_col not in df.columns:\n", + " raise ValueError(f\"Columns {x_col} and/or {y_col} not found in CSV file\")\n", + " \n", + " # Extract data excluding first and last points\n", + " x_full = df[x_col].iloc[1:-1].to_numpy(dtype=float)\n", + " y_full = df[y_col].iloc[1:-1].to_numpy(dtype=float)\n", + " \n", + " # Fit left baseline\n", + " left_coefs = poly.polyfit(x_full[left_start:left_end], \n", + " y_full[left_start:left_end], 1)\n", + " left_b = left_coefs[0]\n", + " left_m = left_coefs[1]\n", + " left_line = left_m*x_full + left_b\n", + " \n", + " # Fit right baseline\n", + " right_coefs = poly.polyfit(x_full[right_start:right_end], \n", + " y_full[right_start:right_end], 1)\n", + " right_b = right_coefs[0]\n", + " right_m = right_coefs[1]\n", + " right_line = right_m*x_full + right_b\n", + " \n", + " # Apply baseline correction\n", + " y_baseline = (y_full - right_line)/(left_b - right_b)\n", + " \n", + " # Apply min/max scaling\n", + " y_final = simple_scaler(y_baseline)\n", + " \n", + " # Create visualization\n", + " fig = plt.figure(figsize=(30, 9))\n", + " \n", + " # Calculate y-axis limits with padding\n", + " y_min = np.min(y_full)\n", + " y_max = np.max(y_full)\n", + " y_range = y_max - y_min\n", + " padding = 3 * y_range\n", + " plot_y_min = y_min - padding\n", + " plot_y_max = y_max + padding\n", + " \n", + " # Panel 1: Original data with baselines\n", + " ax1 = fig.add_subplot(131)\n", + " ax1.scatter(x_full, y_full, s=50, facecolor='none', edgecolor='black', label='Data')\n", + " \n", + " # Plot baselines\n", + " ax1.plot(x_full, poly.polyval(x_full, left_coefs), '-', color=\"blue\", \n", + " label=f'Left baseline ({left_end-left_start} points)')\n", + " ax1.plot(x_full, poly.polyval(x_full, right_coefs), '-', color=\"red\",\n", + " label=f'Right baseline ({right_end-right_start} points)')\n", + " \n", + " # Highlight baseline points\n", + " ax1.scatter(x_full[left_start:left_end], y_full[left_start:left_end], \n", + " color='blue', s=100, alpha=0.3)\n", + " ax1.scatter(x_full[right_start:right_end], y_full[right_start:right_end], \n", + " color='red', s=100, alpha=0.3)\n", + " \n", + " ax1.set_ylim(plot_y_min, plot_y_max)\n", + " ax1.set_title(\"Original Data with Baselines\")\n", + " ax1.set_xlabel(x_col)\n", + " ax1.set_ylabel(y_col)\n", + " ax1.legend()\n", + " \n", + " # Panel 2: Baseline corrected and scaled data\n", + " ax2 = fig.add_subplot(132)\n", + " ax2.scatter(x_full, y_final, color='black', alpha=0.5, label='Corrected data')\n", + " ax2.set_title(\"Baseline Corrected & Scaled\")\n", + " ax2.set_xlabel(x_col)\n", + " ax2.set_ylabel(f\"Corrected {y_col}\")\n", + " ax2.grid(True, linestyle='--', alpha=0.7)\n", + " ax2.set_ylim(0, 1)\n", + " ax2.legend()\n", + " \n", + " # Panel 3: Simply scaled data (no baseline correction)\n", + " ax3 = fig.add_subplot(133)\n", + " y_scaled = simple_scaler(y_full)\n", + " ax3.scatter(x_full, y_scaled, color='black', alpha=0.5, label='Scaled data')\n", + " ax3.set_title(\"Scaled Only (No Baseline Correction)\")\n", + " ax3.set_xlabel(x_col)\n", + " ax3.set_ylabel(f\"Scaled {y_col}\")\n", + " ax3.grid(True, linestyle='--', alpha=0.7)\n", + " ax3.set_ylim(0, 1)\n", + " ax3.legend()\n", + " \n", + " plt.suptitle(f\"Analysis of {y_col} vs {x_col}\")\n", + " plt.tight_layout()\n", + " \n", + " # Setup output paths\n", + " date = Path(filepath).stem\n", + " folder = os.path.basename(os.path.dirname(filepath))\n", + " csv_dir = os.path.dirname(filepath)\n", + " \n", + " output_plot = f\"{date}_{folder}_{y_col}.png\"\n", + " output_csv = f\"{date}_corrected_{y_col}.csv\"\n", + " \n", + " plot_path = os.path.join(csv_dir, output_plot)\n", + " csv_path = os.path.join(csv_dir, output_csv)\n", + " \n", + " # Create output dataframe\n", + " df_output = pd.DataFrame({\n", + " x_col: df[x_col].iloc[1:-1],\n", + " y_col: y_final\n", + " })\n", + " \n", + " # Store the baseline parameters used\n", + " parameters = {\n", + " 'left_start': left_start,\n", + " 'left_end': left_end,\n", + " 'right_start': right_start,\n", + " 'right_end': right_end,\n", + " 'csv_dir': csv_dir\n", + " }\n", + " \n", + " return (y_final, y_col, fig, df_output, \n", + " {\"plot\": plot_path, \"csv\": csv_path, \"dir\": csv_dir}, \n", + " parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "437db2e6-39fc-4030-98c5-71895860fd01", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Running/Visualizing Baseline Correction\n", + "\n", + "csv = r\"C:\\Users\\willi\\Desktop\\20251009_hA4_F55A_Urea_75uMCa\\data.csv\"\n", + "# Get the directory containing the CSV file\n", + "csv_dir = os.path.dirname(csv)\n", + "\n", + "corrected_data, signal, fig, df_output, file_paths, parameters = baseline_corrector(\n", + " csv,\n", + " \"concentration\",\n", + " \"farCD\",\n", + " left_start=0,\n", + " left_end=25,\n", + " right_start=55,\n", + " right_end=89\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9aa651b0-b67b-41e4-a82a-30806309bfde", + "metadata": {}, + "outputs": [], + "source": [ + "## Save the baseline correction as a picture and a csv of the scaled values\n", + "\n", + "fig.savefig(file_paths[\"plot\"], dpi=600, bbox_inches='tight')\n", + "df_output.to_csv(file_paths[\"csv\"], index=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/data/20240806/4mMEDTAinto0uMCa2.csv b/notebooks/data/20240806/4mMEDTAinto0uMCa2.csv new file mode 100644 index 0000000..e01cc46 --- /dev/null +++ b/notebooks/data/20240806/4mMEDTAinto0uMCa2.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-3.84997,0.00384997,True +1.5,-0.01429,1.429e-05,False +1.5,-0.19508,0.00019508,False +1.5,0.07319,7.319000000000001e-05,False +1.5,0.22165,0.00022165000000000002,False +1.5,-0.0317,3.17e-05,False +1.5,-0.11582,0.00011582000000000001,False +1.5,-0.05499,5.499e-05,False +1.5,-0.09219,9.219e-05,False +1.5,-0.08168,8.168e-05,False +1.5,-0.06298,6.298e-05,False +1.5,-0.02626,2.626e-05,False +1.5,-0.04239,4.239e-05,False +1.5,-0.03898,3.898e-05,False +1.5,-0.06617,6.617000000000001e-05,False +1.5,-0.07299,7.299e-05,False +1.5,-0.04972,4.972e-05,False +1.5,-0.12477,0.00012477,False +1.5,-0.06699,6.699e-05,False +1.5,-0.07639,7.639e-05,False +1.5,-0.10027,0.00010027,False +1.5,-0.0755,7.55e-05,False +1.5,-0.04777,4.777e-05,False +1.5,-0.05152,5.152e-05,False +1.5,-0.11661,0.00011661000000000001,False diff --git a/notebooks/data/20240806/4mMEDTAinto0uMCa3.csv b/notebooks/data/20240806/4mMEDTAinto0uMCa3.csv new file mode 100644 index 0000000..16c8539 --- /dev/null +++ b/notebooks/data/20240806/4mMEDTAinto0uMCa3.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-1.89631,0.00189631,True +1.5,-1.91895,0.00191895,False +1.5,-0.1018,0.00010180000000000001,False +1.5,-0.09628,9.628e-05,False +1.5,-0.08349,8.349e-05,False +1.5,-0.03877,3.8769999999999996e-05,False +1.5,-0.07032,7.031999999999999e-05,False +1.5,-0.0595,5.9499999999999996e-05,False +1.5,-0.06149,6.149000000000001e-05,False +1.5,0.00301,3.01e-06,False +1.5,-0.07287,7.287000000000001e-05,False +1.5,-0.1275,0.0001275,False +1.5,-0.05509,5.509e-05,False +1.5,-0.10183,0.00010183,False +1.5,-0.08538,8.538e-05,False +1.5,-0.04531,4.5310000000000005e-05,False +1.5,-0.08082,8.082e-05,False +1.5,-0.10798,0.00010798,False +1.5,-0.08117,8.117000000000001e-05,False +1.5,-0.02931,2.931e-05,False +1.5,-0.06551,6.551e-05,False +1.5,-0.1091,0.00010910000000000001,False +1.5,-0.09955,9.955000000000001e-05,False +1.5,-0.11479,0.00011479,False +1.5,-0.08707,8.706999999999999e-05,False diff --git a/notebooks/data/20240812/4mMEDTAto500uMCa.csv b/notebooks/data/20240812/4mMEDTAto500uMCa.csv new file mode 100644 index 0000000..2acebca --- /dev/null +++ b/notebooks/data/20240812/4mMEDTAto500uMCa.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-55.92043,0.05592043000000001,True +1.5,-74.375,0.074375,False +1.5,-76.30539,0.07630539,False +1.5,-76.74376,0.07674376,False +1.5,-76.72109,0.07672109,False +1.5,-76.30804,0.07630804000000001,False +1.5,-75.73309,0.07573309,False +1.5,-75.5869,0.0755869,False +1.5,-75.62384,0.07562384,False +1.5,-76.01321,0.07601321,False +1.5,-74.84512,0.07484512,False +1.5,-74.64875,0.07464875000000001,False +1.5,-74.01523,0.07401523,False +1.5,-71.61961,0.07161961,False +1.5,-18.80959,0.01880959,False +1.5,-0.53633,0.00053633,False +1.5,-0.16898,0.00016898,False +1.5,-0.06382,6.382000000000001e-05,False +1.5,-0.06345,6.345000000000001e-05,False +1.5,0.01728,1.728e-05,False +1.5,0.14431,0.00014431,False +1.5,-0.03201,3.201e-05,False +1.5,-0.03689,3.689e-05,False +1.5,0.03334,3.334e-05,False +1.5,0.03928,3.9280000000000003e-05,False diff --git a/notebooks/data/20240812/4mMEDTAto500uMCa2.csv b/notebooks/data/20240812/4mMEDTAto500uMCa2.csv new file mode 100644 index 0000000..3750ae7 --- /dev/null +++ b/notebooks/data/20240812/4mMEDTAto500uMCa2.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-59.65305,0.05965305,True +1.5,-76.40768,0.07640768,False +1.5,-76.37731,0.07637730999999999,False +1.5,-76.25639,0.07625639,False +1.5,-76.64331,0.07664331,False +1.5,-76.88572,0.07688572,False +1.5,-72.35377,0.07235377,False +1.5,-77.14984,0.07714984,False +1.5,-75.86415,0.07586414999999999,False +1.5,-75.9471,0.0759471,False +1.5,-75.22472,0.07522472000000001,False +1.5,-75.23027,0.07523027,False +1.5,-75.00314,0.07500314000000001,False +1.5,-74.15422,0.07415421999999999,False +1.5,-43.21534,0.04321534,False +1.5,-1.22985,0.0012298500000000002,False +1.5,-0.0807,8.07e-05,False +1.5,0.11882,0.00011882,False +1.5,0.05022,5.0220000000000004e-05,False +1.5,0.10237,0.00010237000000000001,False +1.5,0.16259,0.00016259000000000003,False +1.5,0.2323,0.0002323,False +1.5,0.13309,0.00013309000000000001,False +1.5,0.11753,0.00011753,False +1.5,0.11112,0.00011111999999999999,False diff --git a/notebooks/data/20240812/4mMEDTAto500uMCa3.csv b/notebooks/data/20240812/4mMEDTAto500uMCa3.csv new file mode 100644 index 0000000..6018c51 --- /dev/null +++ b/notebooks/data/20240812/4mMEDTAto500uMCa3.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-60.08024,0.06008024000000001,True +1.5,-65.20393,0.06520393000000001,False +1.5,-64.10915,0.06410915,False +1.5,-70.91611,0.07091611,False +1.5,-73.25975,0.07325975,False +1.5,-76.5549,0.07655490000000001,False +1.5,-77.45138,0.07745138,False +1.5,-77.72337,0.07772337,False +1.5,-77.66333,0.07766333,False +1.5,-77.74369,0.07774369,False +1.5,-77.041,0.077041,False +1.5,-77.09095,0.07709095,False +1.5,-76.83698,0.07683698,False +1.5,-73.63155,0.07363155,False +1.5,-17.57266,0.01757266,False +1.5,-0.34913,0.00034913,False +1.5,-0.01429,1.429e-05,False +1.5,0.05406,5.406e-05,False +1.5,0.23884,0.00023884,False +1.5,0.19517,0.00019517000000000002,False +1.5,0.18423,0.00018423000000000002,False +1.5,0.18827,0.00018826999999999998,False +1.5,0.19475,0.00019475000000000002,False +1.5,0.16412,0.00016412,False +1.5,0.1281,0.0001281,False diff --git a/notebooks/data/20240813/3mMEDTAto500uMCa.csv b/notebooks/data/20240813/3mMEDTAto500uMCa.csv new file mode 100644 index 0000000..2cf6dab --- /dev/null +++ b/notebooks/data/20240813/3mMEDTAto500uMCa.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-43.08542,0.04308542,True +1.5,-54.7782,0.0547782,False +1.5,-55.78187,0.05578187,False +1.5,-57.06075,0.05706075,False +1.5,-53.19219,0.05319219,False +1.5,-58.26338,0.05826338,False +1.5,-55.85693,0.05585693,False +1.5,-56.0371,0.056037100000000006,False +1.5,-56.0273,0.056027299999999995,False +1.5,-56.24262,0.05624262,False +1.5,-55.75734,0.05575734,False +1.5,-55.79785,0.055797849999999996,False +1.5,-55.6889,0.0556889,False +1.5,-55.72474,0.055724739999999995,False +1.5,-55.62816,0.05562816,False +1.5,-55.22869,0.055228690000000004,False +1.5,-55.38051,0.05538051,False +1.5,-55.12981,0.05512981,False +1.5,-53.94497,0.05394497,False +1.5,-29.77071,0.029770710000000002,False +1.5,-1.49263,0.00149263,False +1.5,-0.22988,0.00022988000000000001,False +1.5,-0.08294,8.294e-05,False +1.5,0.03361,3.361e-05,False +1.5,0.11923,0.00011923000000000001,False diff --git a/notebooks/data/20240813/3mMEDTAto500uMCa2.csv b/notebooks/data/20240813/3mMEDTAto500uMCa2.csv new file mode 100644 index 0000000..142fdaf --- /dev/null +++ b/notebooks/data/20240813/3mMEDTAto500uMCa2.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-42.56976,0.042569760000000005,True +1.5,-55.68075,0.05568075,False +1.5,-55.87438,0.05587438,False +1.5,-55.85245,0.05585245,False +1.5,-56.40125,0.05640125,False +1.5,-56.30869,0.05630869,False +1.5,-55.9284,0.0559284,False +1.5,-56.08896,0.05608896,False +1.5,-56.06765,0.056067650000000004,False +1.5,-55.0219,0.055021900000000006,False +1.5,-53.58998,0.053589979999999995,False +1.5,-56.05268,0.05605268,False +1.5,-56.03423,0.056034230000000004,False +1.5,-56.10625,0.05610625,False +1.5,-55.79769,0.055797690000000004,False +1.5,-55.65447,0.055654470000000004,False +1.5,-55.70874,0.05570874,False +1.5,-55.375,0.055375,False +1.5,-54.44674,0.05444674,False +1.5,-33.8039,0.0338039,False +1.5,-1.99953,0.0019995300000000002,False +1.5,-0.2292,0.0002292,False +1.5,-0.04787,4.787e-05,False +1.5,0.00722,7.22e-06,False +1.5,-0.01356,1.3559999999999999e-05,False diff --git a/notebooks/data/20240813/3mMEDTAto500uMCa3.csv b/notebooks/data/20240813/3mMEDTAto500uMCa3.csv new file mode 100644 index 0000000..11d800e --- /dev/null +++ b/notebooks/data/20240813/3mMEDTAto500uMCa3.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-47.59931,0.047599310000000006,True +1.5,-57.69925,0.05769925,False +1.5,-56.66159,0.05666159,False +1.5,-56.2188,0.056218800000000006,False +1.5,-56.2676,0.0562676,False +1.5,-56.38979,0.05638979,False +1.5,-53.90705,0.05390705,False +1.5,-55.36247,0.055362470000000004,False +1.5,-56.15491,0.05615491,False +1.5,-56.44643,0.05644643,False +1.5,-56.01123,0.05601123,False +1.5,-56.00336,0.05600336,False +1.5,-56.02649,0.056026490000000005,False +1.5,-56.04474,0.056044739999999996,False +1.5,-55.8202,0.0558202,False +1.5,-55.35152,0.05535152,False +1.5,-55.52632,0.05552632,False +1.5,-55.28711,0.05528711,False +1.5,-54.031,0.054031,False +1.5,-29.94026,0.02994026,False +1.5,-1.46439,0.00146439,False +1.5,-0.2095,0.0002095,False +1.5,0.02928,2.928e-05,False +1.5,0.08366,8.366e-05,False +1.5,0.03439,3.4389999999999994e-05,False diff --git a/notebooks/data/20240822/3mMEDTAto50uMhA4.csv b/notebooks/data/20240822/3mMEDTAto50uMhA4.csv new file mode 100644 index 0000000..2e15145 --- /dev/null +++ b/notebooks/data/20240822/3mMEDTAto50uMhA4.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-47.43722,0.04743722,True +1.5,-54.70516,0.05470516,False +1.5,-56.37578,0.05637578,False +1.5,-56.71742,0.05671742,False +1.5,-56.86723,0.05686723,False +1.5,-57.04497,0.05704497,False +1.5,-56.46255,0.05646255,False +1.5,-56.70722,0.05670722,False +1.5,-56.84912,0.05684912,False +1.5,-57.05952,0.05705952,False +1.5,-56.38643,0.05638643,False +1.5,-56.74931,0.056749310000000004,False +1.5,-56.61709,0.05661709,False +1.5,-56.6073,0.056607300000000006,False +1.5,-56.22503,0.056225029999999995,False +1.5,-55.84166,0.05584166,False +1.5,-55.58472,0.05558472,False +1.5,-54.07931,0.05407931,False +1.5,-48.70794,0.048707940000000005,False +1.5,-41.35885,0.041358849999999996,False +1.5,-25.61508,0.02561508,False +1.5,-5.31601,0.00531601,False +1.5,-1.29221,0.00129221,False +1.5,-0.10492,0.00010492,False +1.5,0.2067,0.0002067,False diff --git a/notebooks/data/20240822/3mMEDTAto50uMhA42.csv b/notebooks/data/20240822/3mMEDTAto50uMhA42.csv new file mode 100644 index 0000000..32f1cb8 --- /dev/null +++ b/notebooks/data/20240822/3mMEDTAto50uMhA42.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-45.77775,0.04577775,True +1.5,-54.33094,0.05433094,False +1.5,-54.51675,0.05451675,False +1.5,-55.26758,0.055267580000000004,False +1.5,-55.26515,0.05526515,False +1.5,-55.50151,0.055501510000000004,False +1.5,-55.43068,0.05543068,False +1.5,-55.72041,0.055720410000000005,False +1.5,-55.71175,0.055711750000000004,False +1.5,-56.13871,0.05613871,False +1.5,-55.77914,0.05577914,False +1.5,-55.88506,0.05588506000000001,False +1.5,-55.83294,0.055832940000000005,False +1.5,-55.99042,0.05599042,False +1.5,-55.68956,0.05568956,False +1.5,-55.21179,0.055211790000000004,False +1.5,-54.57792,0.05457792,False +1.5,-53.23423,0.05323423,False +1.5,-48.73079,0.04873079,False +1.5,-41.4842,0.0414842,False +1.5,-30.64624,0.030646239999999998,False +1.5,-6.3608,0.006360800000000001,False +1.5,-0.92876,0.00092876,False +1.5,-0.43418,0.00043418,False +1.5,-0.11897,0.00011897000000000001,False diff --git a/notebooks/data/20240822/3mMEDTAto50uMhA43.csv b/notebooks/data/20240822/3mMEDTAto50uMhA43.csv new file mode 100644 index 0000000..8c55ac8 --- /dev/null +++ b/notebooks/data/20240822/3mMEDTAto50uMhA43.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-44.23813,0.04423813,True +1.5,-54.7172,0.0547172,False +1.5,-55.87178,0.05587178,False +1.5,-55.69478,0.05569478,False +1.5,-55.69722,0.055697220000000006,False +1.5,-55.91784,0.055917839999999996,False +1.5,-55.56047,0.05556047,False +1.5,-55.73695,0.05573695,False +1.5,-55.61162,0.05561162,False +1.5,-55.98779,0.055987789999999996,False +1.5,-55.4681,0.0554681,False +1.5,-55.57546,0.05557546,False +1.5,-55.48715,0.05548715,False +1.5,-55.24325,0.05524325000000001,False +1.5,-55.16216,0.05516216,False +1.5,-54.22271,0.05422271,False +1.5,-53.9215,0.053921500000000004,False +1.5,-51.06997,0.05106997,False +1.5,-43.91537,0.04391537,False +1.5,-35.78301,0.03578301,False +1.5,-11.46808,0.01146808,False +1.5,-1.37263,0.0013726300000000001,False +1.5,-0.37292,0.00037292,False +1.5,-0.3824,0.0003824,False +1.5,-0.29306,0.00029306,False diff --git a/notebooks/data/20240823/3mMEDTAto50uMhA4.csv b/notebooks/data/20240823/3mMEDTAto50uMhA4.csv new file mode 100644 index 0000000..4578700 --- /dev/null +++ b/notebooks/data/20240823/3mMEDTAto50uMhA4.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-44.39263,0.044392629999999995,True +1.5,-53.58409,0.05358409000000001,False +1.5,-54.325,0.054325000000000005,False +1.5,-54.04732,0.05404732,False +1.5,-54.71533,0.05471533,False +1.5,-55.18508,0.05518508,False +1.5,-55.75275,0.05575275,False +1.5,-56.88996,0.05688996,False +1.5,-57.48466,0.05748466,False +1.5,-57.81205,0.057812050000000004,False +1.5,-57.29952,0.05729952,False +1.5,-57.48364,0.05748364,False +1.5,-57.53602,0.05753602,False +1.5,-57.57876,0.05757876000000001,False +1.5,-57.25204,0.057252040000000004,False +1.5,-56.79107,0.05679107,False +1.5,-55.98985,0.05598985,False +1.5,-52.75322,0.05275322,False +1.5,-45.27547,0.04527547,False +1.5,-36.40477,0.03640477,False +1.5,-11.00531,0.01100531,False +1.5,-1.5601,0.0015601,False +1.5,-1.95837,0.00195837,False +1.5,-0.27784,0.00027783999999999996,False +1.5,-0.0625,6.25e-05,False diff --git a/notebooks/data/20240826/200uMA6pepto50uMhA4.csv b/notebooks/data/20240826/200uMA6pepto50uMhA4.csv new file mode 100644 index 0000000..efaa328 --- /dev/null +++ b/notebooks/data/20240826/200uMA6pepto50uMhA4.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,0.13485,0.00013485,True +1.5,-0.37862,0.00037862000000000003,False +1.5,-0.46126,0.00046126,False +1.5,-0.4034,0.0004034,False +1.5,-0.41179,0.00041179,False +1.5,-0.42,0.00042,False +1.5,-0.37896,0.00037896,False +1.5,-0.48754,0.00048753999999999996,False +1.5,-0.5143,0.0005143,False +1.5,-0.45842,0.00045842,False +1.5,-0.45715,0.00045715,False +1.5,-0.38733,0.00038733,False +1.5,-0.45329,0.00045329,False +1.5,-0.47198,0.00047198000000000004,False +1.5,-0.41489,0.00041489,False +1.5,-0.39676,0.00039676,False +1.5,-0.43309,0.00043308999999999996,False +1.5,-0.46789,0.00046789,False +1.5,-0.43139,0.00043139000000000003,False +1.5,-0.47455,0.00047455,False +1.5,-0.4633,0.0004633,False +1.5,-0.43244,0.00043244,False +1.5,-0.41009,0.00041009,False +1.5,-0.3922,0.0003922,False +1.5,-0.34363,0.00034363,False diff --git a/notebooks/data/20240826/3mMEDTAtoPepProtCa.csv b/notebooks/data/20240826/3mMEDTAtoPepProtCa.csv new file mode 100644 index 0000000..10e4559 --- /dev/null +++ b/notebooks/data/20240826/3mMEDTAtoPepProtCa.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-24.41922,0.02441922,True +1.5,-28.93266,0.02893266,False +1.5,-29.18596,0.02918596,False +1.5,-28.98133,0.02898133,False +1.5,-29.13515,0.02913515,False +1.5,-29.39403,0.02939403,False +1.5,-29.41985,0.02941985,False +1.5,-29.69344,0.029693439999999998,False +1.5,-30.07138,0.03007138,False +1.5,-30.57521,0.03057521,False +1.5,-30.64005,0.03064005,False +1.5,-31.39824,0.03139824,False +1.5,-32.03397,0.032033969999999995,False +1.5,-33.13441,0.03313441,False +1.5,-34.03181,0.03403181,False +1.5,-36.38884,0.036388840000000006,False +1.5,-38.73642,0.03873642,False +1.5,-42.03,0.042030000000000005,False +1.5,-45.0333,0.0450333,False +1.5,-41.09869,0.04109869,False +1.5,-26.08904,0.02608904,False +1.5,-4.31099,0.004310990000000001,False +1.5,-0.78758,0.00078758,False +1.5,-0.37359,0.00037359,False +1.5,-0.10914,0.00010914,False diff --git a/notebooks/data/20240826/3mMEDTAtoPepProtCa2.csv b/notebooks/data/20240826/3mMEDTAtoPepProtCa2.csv new file mode 100644 index 0000000..63f6d83 --- /dev/null +++ b/notebooks/data/20240826/3mMEDTAtoPepProtCa2.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-39.19548,0.039195480000000005,True +1.5,-51.56021,0.05156021,False +1.5,-51.78179,0.05178179,False +1.5,-51.45539,0.051455390000000004,False +1.5,-51.79969,0.05179969,False +1.5,-52.20234,0.05220234,False +1.5,-52.4981,0.0524981,False +1.5,-52.19472,0.05219472,False +1.5,-52.94124,0.05294124,False +1.5,-57.23272,0.05723272,False +1.5,-49.91622,0.049916220000000004,False +1.5,-56.62087,0.05662087,False +1.5,-56.8448,0.0568448,False +1.5,-57.20666,0.05720666,False +1.5,-56.93663,0.05693663,False +1.5,-56.23687,0.05623687,False +1.5,-55.90197,0.05590197,False +1.5,-54.1652,0.0541652,False +1.5,-48.79006,0.048790059999999996,False +1.5,-37.11472,0.03711472,False +1.5,-15.75693,0.015756930000000002,False +1.5,-2.7443,0.0027443,False +1.5,-0.16014,0.00016014,False +1.5,-0.08434,8.434e-05,False +1.5,-0.0527,5.27e-05,False diff --git a/notebooks/data/20240826/3mMEDTAtoPepProtCa3.csv b/notebooks/data/20240826/3mMEDTAtoPepProtCa3.csv new file mode 100644 index 0000000..34f5fd2 --- /dev/null +++ b/notebooks/data/20240826/3mMEDTAtoPepProtCa3.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-39.34121,0.039341209999999995,True +1.5,-45.29259,0.04529259,False +1.5,-45.84224,0.04584224,False +1.5,-45.80604,0.045806040000000006,False +1.5,-46.17643,0.046176430000000004,False +1.5,-45.62014,0.04562014,False +1.5,-54.97227,0.054972270000000004,False +1.5,-48.94505,0.048945050000000004,False +1.5,-51.3745,0.0513745,False +1.5,-57.964,0.057964,False +1.5,-52.45817,0.052458170000000005,False +1.5,-59.06816,0.05906816,False +1.5,-56.25571,0.05625571,False +1.5,-48.32279,0.04832279,False +1.5,-35.32686,0.03532686,False +1.5,-10.47122,0.010471220000000002,False +1.5,-2.16695,0.00216695,False +1.5,4.2209,0.0042209000000000005,False +1.5,-1.81572,0.00181572,False +1.5,4.2151,0.004215099999999999,False +1.5,-1.34441,0.00134441,False +1.5,2.52291,0.00252291,False +1.5,4.93425,0.004934249999999999,False +1.5,-1.27581,0.00127581,False +1.5,1.59655,0.00159655,False diff --git a/notebooks/data/20240904/3mMEDTAto500uMCal200uMPep.csv b/notebooks/data/20240904/3mMEDTAto500uMCal200uMPep.csv new file mode 100644 index 0000000..cd7e571 --- /dev/null +++ b/notebooks/data/20240904/3mMEDTAto500uMCal200uMPep.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-40.4784,0.040478400000000005,True +1.5,-43.48645,0.043486449999999996,False +1.5,-44.59015,0.04459015,False +1.5,-43.15777,0.04315777,False +1.5,-46.7423,0.0467423,False +1.5,-47.26428,0.04726428,False +1.5,-43.52767,0.043527670000000004,False +1.5,-45.13109,0.04513109,False +1.5,-46.05818,0.046058180000000004,False +1.5,-45.33002,0.04533002,False +1.5,-45.31554,0.04531554,False +1.5,-46.1279,0.0461279,False +1.5,-46.44451,0.04644451,False +1.5,-47.34506,0.047345059999999994,False +1.5,-50.42373,0.05042373,False +1.5,-55.0201,0.0550201,False +1.5,-57.28586,0.05728586,False +1.5,-55.60415,0.05560415,False +1.5,-53.57958,0.05357958,False +1.5,-50.61248,0.05061248,False +1.5,-48.89214,0.04889214,False +1.5,-39.98451,0.03998451,False +1.5,-15.83873,0.01583873,False +1.5,-2.56046,0.00256046,False +1.5,-0.08241,8.241e-05,False diff --git a/notebooks/data/20240904/3mMEDTAto500uMCal200uMPep2.csv b/notebooks/data/20240904/3mMEDTAto500uMCal200uMPep2.csv new file mode 100644 index 0000000..a310655 --- /dev/null +++ b/notebooks/data/20240904/3mMEDTAto500uMCal200uMPep2.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.35,-48.16389,0.04816389,True +1.5001,-50.52313,0.050523130000000006,False +1.5001,-47.97538,0.047975380000000005,False +1.5001,-49.71093,0.04971093,False +1.5001,-50.06888,0.05006888,False +1.5001,-50.93718,0.05093718,False +1.5001,-51.12986,0.05112986,False +1.5001,-52.34966,0.05234966,False +1.5001,-51.40656,0.05140656,False +1.5001,-50.70122,0.05070122,False +1.5001,-50.75037,0.050750369999999996,False +1.5001,-53.35349,0.05335349,False +1.5001,-55.02783,0.05502783,False +1.5001,-56.11853,0.05611853,False +1.5001,-55.85969,0.055859690000000004,False +1.5001,-55.06507,0.05506507,False +1.5,-54.64444,0.05464444,False +1.5,-54.27207,0.05427207,False +1.5,-53.53158,0.05353158,False +1.5,-51.77909,0.05177909,False +1.5,-48.70545,0.04870545,False +1.5,-35.83217,0.035832169999999997,False +1.5,-11.4892,0.0114892,False +1.5,-1.53934,0.00153934,False +1.5,-0.04329,4.329e-05,False diff --git a/notebooks/data/20240911/3mMEDTAto500uMCanewinjreg.csv b/notebooks/data/20240911/3mMEDTAto500uMCanewinjreg.csv new file mode 100644 index 0000000..fda2322 --- /dev/null +++ b/notebooks/data/20240911/3mMEDTAto500uMCanewinjreg.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-43.55239,0.04355239,True +1.5001,-55.15164,0.05515164,False +1.5001,-55.24487,0.05524487,False +1.5001,-55.11563,0.055115630000000006,False +1.5001,-52.6072,0.0526072,False +1.5001,-55.83644,0.05583644,False +1.5001,-54.91872,0.054918720000000004,False +1.5001,-55.06646,0.05506646,False +1.5001,-55.40612,0.05540612,False +1.5001,-55.7207,0.055720700000000005,False +1.5001,-55.19716,0.055197159999999995,False +1.5001,-54.87701,0.05487701,False +1.5001,-54.82708,0.05482708,False +1.5001,-54.7709,0.0547709,False +1.5001,-54.71221,0.05471221,False +1.5001,-54.40994,0.05440994,False +0.5001,-17.93324,0.017933240000000003,False +0.5001,-17.89662,0.01789662,False +0.5001,-17.85996,0.01785996,False +0.5001,-17.79867,0.017798670000000003,False +0.5001,-17.78522,0.01778522,False +0.5001,-17.73078,0.017730779999999998,False +0.5001,-17.80013,0.01780013,False +0.5001,-17.52538,0.01752538,False +0.5001,-17.28763,0.017287630000000002,False +0.5001,-16.42499,0.01642499,False +0.5001,-13.54416,0.01354416,False +0.5001,-5.9964,0.005996400000000001,False +0.5001,-1.48915,0.00148915,False +0.5001,-0.56002,0.0005600199999999999,False +0.5001,-0.30253,0.00030253,False +0.5001,-0.18791,0.00018791,False +0.5001,-0.09908,9.908000000000001e-05,False +0.5001,-0.09056,9.056e-05,False +0.5001,-0.07653,7.653e-05,False +0.5001,0.00793,7.93e-06,False +0.5001,-0.03339,3.3390000000000004e-05,False +0.5001,-0.04315,4.315e-05,False +0.5001,0.0484,4.84e-05,False +0.5001,-0.04435,4.435e-05,False +0.5001,-0.01707,1.7069999999999998e-05,False +0.5001,-0.05095,5.0950000000000005e-05,False +0.5001,-0.03682,3.6819999999999996e-05,False diff --git a/notebooks/data/20240912/3mMEDTAto500uMCaCl2.csv b/notebooks/data/20240912/3mMEDTAto500uMCaCl2.csv new file mode 100644 index 0000000..54383da --- /dev/null +++ b/notebooks/data/20240912/3mMEDTAto500uMCaCl2.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-45.00858,0.045008580000000006,True +1.5001,-47.49957,0.04749957,False +1.5001,-47.94222,0.04794222,False +1.5001,-48.84612,0.04884612,False +1.5001,-47.9966,0.0479966,False +1.5001,-51.15606,0.051156059999999996,False +1.5001,-52.5889,0.0525889,False +1.5001,-54.24079,0.05424079,False +1.5001,-55.31206,0.05531206,False +1.5001,-55.55272,0.05555272,False +1.5001,-55.02274,0.05502274,False +1.5001,-54.97478,0.05497478,False +1.5001,-54.91492,0.054914920000000006,False +1.5001,-54.93987,0.05493987,False +1.5001,-54.57739,0.05457739,False +1.5001,-54.21918,0.054219180000000006,False +0.5001,-17.88292,0.01788292,False +0.5001,-17.8827,0.0178827,False +0.5001,-17.96016,0.01796016,False +0.5001,-17.47006,0.01747006,False +0.5001,-17.82432,0.01782432,False +0.5001,-17.84496,0.01784496,False +0.5001,-17.62068,0.01762068,False +0.5001,-17.39136,0.017391359999999998,False +0.5001,-16.64568,0.01664568,False +0.5001,-13.74321,0.01374321,False +0.5001,-6.23169,0.006231690000000001,False +0.5001,-1.50417,0.00150417,False +0.5001,-0.53911,0.00053911,False +0.5001,-0.31809,0.00031809,False +0.5001,-0.35417,0.00035417,False +0.5001,-0.20119,0.00020119000000000002,False +0.5001,-0.0867,8.67e-05,False +0.5001,-0.10226,0.00010226,False +0.5001,0.01982,1.982e-05,False +0.5001,-0.05646,5.6460000000000005e-05,False +0.5001,0.06296,6.296000000000001e-05,False +0.5001,0.00544,5.4400000000000004e-06,False +0.5001,-0.00584,5.84e-06,False +0.5001,0.01389,1.3889999999999999e-05,False +0.5001,0.08238,8.238e-05,False +0.5001,0.16609,0.00016609,False +0.5001,0.18516,0.00018516,False diff --git a/notebooks/data/20240912/3mMEDTAto500uMCaCl2_2.csv b/notebooks/data/20240912/3mMEDTAto500uMCaCl2_2.csv new file mode 100644 index 0000000..229ddc2 --- /dev/null +++ b/notebooks/data/20240912/3mMEDTAto500uMCaCl2_2.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-40.31921,0.04031921,True +1.5001,-50.94396,0.050943959999999996,False +1.5001,-48.53671,0.048536710000000004,False +1.5001,-52.08845,0.05208845,False +1.5001,-51.05446,0.05105446,False +1.5001,-52.06968,0.05206968,False +1.5001,-52.94526,0.05294526,False +1.5001,-54.99496,0.05499496,False +1.5001,-55.05545,0.05505545,False +1.5001,-55.2137,0.055213700000000004,False +1.5001,-54.69701,0.05469701,False +1.5001,-54.69689,0.054696890000000005,False +1.5001,-54.6212,0.0546212,False +1.5001,-54.80109,0.054801090000000004,False +1.5001,-54.66552,0.05466552,False +1.5001,-54.43437,0.05443437,False +0.5001,-18.01846,0.01801846,False +0.5001,-18.1224,0.0181224,False +0.5001,-17.95682,0.017956820000000002,False +0.5001,-17.83172,0.017831720000000002,False +0.5001,-17.81118,0.01781118,False +0.5001,-17.7561,0.0177561,False +0.5001,-17.42196,0.01742196,False +0.5001,-16.07464,0.016074639999999998,False +0.5001,-10.7181,0.0107181,False +0.5001,-0.75231,0.0007523100000000001,False +0.5001,2.28166,0.00228166,False +0.5001,2.09795,0.00209795,False +0.5001,1.44804,0.00144804,False +0.5001,0.47618,0.00047618,False +0.5001,0.0697,6.97e-05,False +0.5001,0.27546,0.00027546,False +0.5001,1.58165,0.00158165,False +0.5001,-0.00433,4.33e-06,False +0.5001,-0.11224,0.00011224000000000001,False +0.5001,-0.04631,4.6309999999999995e-05,False +0.5001,-0.32572,0.00032572,False +0.5001,0.12319,0.00012319,False +0.5001,-0.10969,0.00010969,False +0.5001,-0.05385,5.385e-05,False +0.5001,-0.10451,0.00010451000000000001,False +0.5001,-0.1808,0.0001808,False +0.5001,-0.20105,0.00020105,False diff --git a/notebooks/data/20240912/3mMEDTAto500uMCaCl2_3.csv b/notebooks/data/20240912/3mMEDTAto500uMCaCl2_3.csv new file mode 100644 index 0000000..b89f24f --- /dev/null +++ b/notebooks/data/20240912/3mMEDTAto500uMCaCl2_3.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-41.1987,0.041198700000000005,True +1.5001,-50.97716,0.05097716,False +1.5001,-55.45676,0.05545676,False +1.5001,-53.01361,0.05301361,False +1.5001,-55.4633,0.0554633,False +1.5001,-57.0268,0.0570268,False +1.5001,-56.93393,0.05693393,False +1.5001,-56.8957,0.0568957,False +1.5001,-56.37884,0.05637884,False +1.5001,-56.34992,0.05634992,False +1.5001,-55.40544,0.05540544,False +1.5001,-55.45237,0.05545237,False +1.5001,-55.52424,0.05552424,False +1.5001,-55.56149,0.05556149,False +1.5001,-55.64543,0.055645429999999996,False +1.5001,-55.13206,0.055132060000000004,False +0.5001,-17.9488,0.017948799999999997,False +0.5001,-18.18468,0.01818468,False +0.5001,-18.09945,0.018099450000000003,False +0.5001,-18.5069,0.018506900000000003,False +0.5001,-18.12862,0.01812862,False +0.5001,-17.83155,0.01783155,False +0.5001,-18.05698,0.01805698,False +0.5001,-17.91199,0.01791199,False +0.5001,-17.35807,0.017358070000000003,False +0.5001,-16.84776,0.01684776,False +0.5001,-14.33288,0.01433288,False +0.5001,-6.57857,0.006578570000000001,False +0.5001,-1.65542,0.00165542,False +0.5001,-0.59079,0.00059079,False +0.5001,-0.3237,0.0003237,False +0.5001,-0.11553,0.00011553,False +0.5001,-0.14026,0.00014026,False +0.5001,-0.16867,0.00016867,False +0.5001,0.000810699,8.10699e-07,False +0.5001,-0.10309,0.00010309,False +0.5001,0.03316,3.316e-05,False +0.5001,-0.01707,1.7069999999999998e-05,False +0.5001,0.00446,4.4600000000000005e-06,False +0.5001,-0.03873,3.8730000000000004e-05,False +0.5001,-0.0299,2.9900000000000002e-05,False +0.5001,-0.06913,6.913e-05,False +0.5001,0.04218,4.2180000000000006e-05,False diff --git a/notebooks/data/20240913/3p5mMEDTAto500uMCaLOWRES.csv b/notebooks/data/20240913/3p5mMEDTAto500uMCaLOWRES.csv new file mode 100644 index 0000000..df96244 --- /dev/null +++ b/notebooks/data/20240913/3p5mMEDTAto500uMCaLOWRES.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.5,-50.61801,0.05061801,True +1.5,-57.14406,0.05714406,False +1.5,-57.41127,0.05741127,False +1.5,-57.97048,0.057970480000000005,False +1.5,-54.67897,0.05467897,False +1.5,-60.78891,0.06078891,False +1.5,-60.575,0.060575000000000004,False +1.5,-61.70602,0.06170602,False +1.5,-62.72872,0.06272872,False +1.5,-64.31792,0.06431792,False +1.5,-64.42382,0.06442382,False +1.5,-65.08568,0.06508567999999999,False +1.5,-64.91583,0.06491583000000001,False +1.5,-61.62872,0.061628720000000005,False +1.5,-64.32289,0.06432289000000001,False +1.5,-62.94261,0.06294261000000001,False +1.5,-33.12,0.03312,False +1.5,-0.52957,0.00052957,False +1.5,0.28658,0.00028658,False +1.5,0.2389,0.0002389,False +1.5,0.25223,0.00025223,False +1.5,0.00297,2.97e-06,False +1.5,-0.08992,8.992e-05,False +1.5,0.37721,0.00037721,False +1.5,0.17638,0.00017638000000000002,False diff --git a/notebooks/data/20240913/3p5mMEDTAto50uMhA4HIGHRES.csv b/notebooks/data/20240913/3p5mMEDTAto50uMhA4HIGHRES.csv new file mode 100644 index 0000000..e9236cb --- /dev/null +++ b/notebooks/data/20240913/3p5mMEDTAto50uMhA4HIGHRES.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-52.15708,0.05215708,True +1.5001,-65.8029,0.0658029,True +1.5001,-65.39585,0.06539584999999999,False +1.5001,-66.49557,0.06649557,False +1.5001,-68.15952,0.06815952,False +1.5001,-67.96178,0.06796178,False +1.5001,-63.3485,0.0633485,False +1.5001,-67.30918,0.06730918,False +1.5001,-67.31082,0.06731082000000001,False +1.5001,-67.56033,0.06756032999999999,False +1.5001,-67.01412,0.06701412000000001,False +1.5001,-67.01271,0.06701271,False +1.5001,-66.67187,0.06667187,False +1.5001,-66.27511,0.06627511,False +1.5001,-64.45215,0.06445215,False +1.5001,-56.03694,0.05603694,False +0.5001,-16.01268,0.01601268,False +0.5001,-14.2671,0.0142671,False +0.5001,-10.97539,0.010975390000000002,False +0.5001,-5.38568,0.00538568,False +0.5001,-1.87727,0.0018772700000000001,False +0.5001,-0.76716,0.00076716,False +0.5001,-0.46795,0.00046794999999999996,False +0.5001,-0.26876,0.00026876,False +0.5001,-0.19447,0.00019447,False +0.5001,-0.13224,0.00013224,False +0.5001,-0.12541,0.00012541,False +0.5001,-0.10213,0.00010213,False +0.5001,-0.04001,4.001e-05,False +0.5001,-0.0025,2.5e-06,False +0.5001,-0.108,0.000108,False +0.5001,-0.08212,8.212e-05,False +0.5001,-0.14673,0.00014673,False +0.5001,-0.07383,7.383e-05,False +0.5001,-0.07793,7.793e-05,False +0.5001,-0.03984,3.984e-05,False +0.5001,0.01632,1.6320000000000003e-05,False +0.5001,-0.04869,4.8689999999999996e-05,False +0.5001,-0.0267,2.6700000000000002e-05,False +0.5001,-0.02032,2.0320000000000002e-05,False +0.5001,-0.11016,0.00011016,False +0.5001,-0.06384,6.384e-05,False +0.5001,0.01966,1.966e-05,False diff --git a/notebooks/data/20240913/3p5mMEDTAto50uMhA4SUPERDUPERRES.csv b/notebooks/data/20240913/3p5mMEDTAto50uMhA4SUPERDUPERRES.csv new file mode 100644 index 0000000..4ef0dad --- /dev/null +++ b/notebooks/data/20240913/3p5mMEDTAto50uMhA4SUPERDUPERRES.csv @@ -0,0 +1,73 @@ +injection,heat,heat_stdev,ignore_point +2.85,-68.04434,0.06804434000000001,True +0.5,-21.12066,0.021120660000000003,False +0.5,-22.21284,0.02221284,False +0.5,-22.12476,0.02212476,False +0.5,-22.16001,0.02216001,False +0.5,-22.15433,0.022154330000000003,False +0.5,-22.27078,0.02227078,False +0.5,-22.16581,0.02216581,False +0.5,-22.13421,0.02213421,False +0.5,-22.27428,0.02227428,False +0.5,-22.18312,0.02218312,False +0.5,-22.23351,0.022233509999999998,False +0.5,-22.26036,0.02226036,False +0.5,-22.29793,0.02229793,False +0.5,-22.22513,0.02222513,False +0.5,-21.96129,0.02196129,False +0.5,-22.00438,0.02200438,False +0.5,-22.22289,0.02222289,False +0.5,-22.0623,0.0220623,False +0.5,-22.2468,0.0222468,False +0.5,-22.22423,0.022224229999999998,False +0.5,-22.19542,0.02219542,False +0.5,-22.17708,0.022177080000000002,False +0.5,-22.19133,0.022191330000000002,False +0.5,-22.19179,0.022191790000000003,False +0.5,-22.14798,0.02214798,False +0.5,-22.30357,0.02230357,False +0.5,-22.27074,0.02227074,False +0.5,-21.93857,0.021938569999999998,False +0.5,-21.8593,0.0218593,False +0.5,-22.03593,0.022035930000000002,False +0.5,-22.0538,0.0220538,False +0.5,-22.0179,0.0220179,False +0.5,-21.98123,0.02198123,False +0.5,-21.96058,0.02196058,False +0.5,-21.90049,0.02190049,False +0.5,-21.89769,0.02189769,False +0.5,-21.87408,0.02187408,False +0.5,-21.78201,0.02178201,False +0.5,-21.52616,0.021526160000000003,False +0.5,-21.36607,0.02136607,False +0.5,-21.07651,0.02107651,False +0.5,-20.16482,0.02016482,False +0.5,-18.99791,0.01899791,False +0.5,-17.47727,0.01747727,False +0.5,-16.16833,0.01616833,False +0.5,-14.9226,0.0149226,False +0.5,-12.08638,0.01208638,False +0.5,-6.61445,0.00661445,False +0.5,-2.37295,0.00237295,False +0.5,-0.93033,0.00093033,False +0.5,-0.49239,0.00049239,False +0.5,-0.32018,0.00032018000000000004,False +0.5,-0.11787,0.00011787000000000001,False +0.5,-0.13386,0.00013386000000000002,False +0.5,-0.12091,0.00012091,False +0.5,-0.0629,6.29e-05,False +0.5,-0.08083,8.083e-05,False +0.5,-0.00596,5.9600000000000005e-06,False +0.5,-0.02565,2.565e-05,False +0.5,-0.00502,5.02e-06,False +0.5,-0.02297,2.2970000000000002e-05,False +0.5,-0.02786,2.786e-05,False +0.5,-0.07559,7.559e-05,False +0.5,-0.01881,1.881e-05,False +0.5,0.11262,0.00011262,False +0.5,-0.17159,0.00017159,False +0.5,-0.04342,4.342e-05,False +0.5,-0.01796,1.796e-05,False +0.5,-0.05436,5.436e-05,False +0.5,-0.00724,7.24e-06,False +0.5,-0.01373,1.3729999999999999e-05,False diff --git a/notebooks/data/20240915/3p5mMEDTAto500uMCaCl2lowres.csv b/notebooks/data/20240915/3p5mMEDTAto500uMCaCl2lowres.csv new file mode 100644 index 0000000..aeeb32e --- /dev/null +++ b/notebooks/data/20240915/3p5mMEDTAto500uMCaCl2lowres.csv @@ -0,0 +1,26 @@ +injection,heat,heat_stdev,ignore_point +2.5,-89.33348,0.08933347999999999,True +1.5,-65.18311,0.06518311,False +1.5,-64.60486,0.06460486,False +1.5,-65.14234,0.06514234,False +1.5,-64.84542,0.06484542,False +1.5,-64.94643,0.06494643000000001,False +1.5,-64.87648,0.06487648,False +1.5,-64.60259,0.06460259,False +1.5,-64.87962,0.06487962,False +1.5,-65.03677,0.06503677000000001,False +1.5,-65.17161,0.06517161,False +1.5,-64.81621,0.06481621,False +1.5,-64.43665,0.06443665,False +1.5,-63.4552,0.0634552,False +1.5,-47.57245,0.04757245,False +1.5,-2.26317,0.00226317,False +1.5,-0.05996,5.996e-05,False +1.5,-0.07693,7.693e-05,False +1.5,-0.03239,3.239e-05,False +1.5,-0.05432,5.432e-05,False +1.5,0.01332,1.3320000000000001e-05,False +1.5,-0.01039,1.039e-05,False +1.5,0.09988,9.988e-05,False +1.5,0.04294,4.294e-05,False +1.5,-0.0205,2.05e-05,False diff --git a/notebooks/data/20240921/3p5mMEDTAto50uMancA4HR.csv b/notebooks/data/20240921/3p5mMEDTAto50uMancA4HR.csv new file mode 100644 index 0000000..08fdca0 --- /dev/null +++ b/notebooks/data/20240921/3p5mMEDTAto50uMancA4HR.csv @@ -0,0 +1,50 @@ +injection,heat,heat_stdev,ignore_point +2.35,-55.36455,0.055364550000000005,True +1.5,-69.32474,0.06932474000000001,False +1.5,-69.34624,0.06934623999999999,False +1.5,-68.44116,0.06844116,False +1.5,-69.63482,0.06963482,False +1.5,-69.49707,0.06949707,False +1.5,-68.46284,0.06846284,False +1.5,-68.78231,0.06878231,False +1.5,-68.9793,0.0689793,False +1.5,-69.30615,0.06930615,False +1.5,-68.50466,0.06850466000000001,False +1.5,-68.50501,0.06850501,False +1.5,-68.14918,0.06814918,False +0.5,-22.06349,0.02206349,False +0.5,-22.27039,0.02227039,False +0.5,-22.21987,0.02221987,False +0.5,-22.07859,0.02207859,False +0.5,-21.87828,0.02187828,False +0.5,-21.42072,0.02142072,False +0.5,-20.68249,0.02068249,False +0.5,-19.7417,0.0197417,False +0.5,-18.74958,0.018749580000000002,False +0.5,-17.63254,0.01763254,False +0.5,-16.62345,0.016623449999999998,False +0.5,-15.54968,0.015549680000000001,False +0.5,-14.72713,0.014727130000000001,False +0.5,-13.41109,0.01341109,False +0.5,-10.90027,0.010900270000000002,False +0.5,-6.28506,0.006285059999999999,False +0.5,-2.44434,0.00244434,False +0.5,-0.92201,0.00092201,False +0.5,-0.52672,0.0005267199999999999,False +0.5,-0.30652,0.00030652,False +0.5,-0.09931,9.931e-05,False +0.5,-0.1083,0.00010829999999999999,False +0.5,-0.09669,9.669e-05,False +0.5,-0.10945,0.00010945,False +0.5,-0.03756,3.7560000000000006e-05,False +0.5,-0.00986,9.86e-06,False +0.5,0.07208,7.208e-05,False +0.5,0.03539,3.539e-05,False +0.5,-0.01839,1.8390000000000002e-05,False +0.5,-0.00487,4.87e-06,False +0.5,0.0476,4.7600000000000005e-05,False +0.5,0.02016,2.016e-05,False +0.5,0.08828,8.828e-05,False +0.5,0.0352,3.52e-05,False +0.5,0.02086,2.086e-05,False +0.5,0.03664,3.664e-05,False diff --git a/notebooks/data/20240921/3p5mMEDTAto50uMancA4HR2.csv b/notebooks/data/20240921/3p5mMEDTAto50uMancA4HR2.csv new file mode 100644 index 0000000..67a2242 --- /dev/null +++ b/notebooks/data/20240921/3p5mMEDTAto50uMancA4HR2.csv @@ -0,0 +1,74 @@ +injection,heat,heat_stdev,ignore_point +2.35,-55.97788,0.05597788,True +0.5,-21.95053,0.02195053,False +0.5,-22.42931,0.02242931,False +0.5,-21.18974,0.021189740000000002,False +0.5,-22.40607,0.02240607,False +0.5,-22.49551,0.02249551,False +0.5,-22.38521,0.022385210000000003,False +0.5,-22.64094,0.022640940000000002,False +0.5,-22.64039,0.02264039,False +0.5,-22.65971,0.02265971,False +0.5,-22.85706,0.022857060000000002,False +0.5,-22.8363,0.0228363,False +0.5,-22.8603,0.0228603,False +0.5,-22.88615,0.02288615,False +0.5,-22.85894,0.02285894,False +0.5,-22.67414,0.022674140000000002,False +0.5,-22.53739,0.022537389999999997,False +0.5,-22.63825,0.02263825,False +0.5,-22.72017,0.02272017,False +0.5,-22.74408,0.02274408,False +0.5,-22.77404,0.02277404,False +0.5,-22.71266,0.02271266,False +0.5,-22.68784,0.02268784,False +0.5,-22.78963,0.022789629999999998,False +0.5,-22.71327,0.02271327,False +0.5,-22.7017,0.0227017,False +0.5,-22.94891,0.022948910000000003,False +0.5,-22.73536,0.02273536,False +0.5,-22.70927,0.02270927,False +0.5,-22.51936,0.02251936,False +0.5,-22.36225,0.02236225,False +0.5,-22.48918,0.02248918,False +0.5,-22.65107,0.022651070000000002,False +0.5,-22.59551,0.022595510000000003,False +0.5,-22.57221,0.02257221,False +0.5,-22.46789,0.02246789,False +0.5,-22.34043,0.02234043,False +0.5,-22.29317,0.02229317,False +0.5,-22.26449,0.022264489999999998,False +0.5,-22.04792,0.022047920000000002,False +0.5,-21.69845,0.02169845,False +0.5,-21.2705,0.021270499999999998,False +0.5,-20.48676,0.02048676,False +0.5,-19.36719,0.019367190000000003,False +0.5,-18.15499,0.018154990000000003,False +0.5,-17.17279,0.01717279,False +0.5,-16.12606,0.016126059999999998,False +0.5,-15.17802,0.01517802,False +0.5,-14.08457,0.01408457,False +0.5,-12.48072,0.01248072,False +0.5,-8.97425,0.00897425,False +0.5,-4.15965,0.00415965,False +0.5,-1.57152,0.00157152,False +0.5,-0.6606,0.0006606,False +0.5,-0.42848,0.00042848,False +0.5,-0.23826,0.00023826,False +0.5,-0.16221,0.00016221,False +0.5,-0.1502,0.0001502,False +0.5,-0.00738,7.3800000000000005e-06,False +0.5,-0.05483,5.4829999999999995e-05,False +0.5,-0.03609,3.6089999999999995e-05,False +0.5,-0.04386,4.3860000000000004e-05,False +0.5,-0.01553,1.5530000000000002e-05,False +0.5,0.00117,1.17e-06,False +0.5,0.03996,3.9960000000000004e-05,False +0.5,0.03985,3.985e-05,False +0.5,-0.0011,1.1e-06,False +0.5,0.08101,8.101e-05,False +0.5,0.02475,2.4750000000000002e-05,False +0.5,0.02091,2.091e-05,False +0.5,-0.03111,3.111e-05,False +0.5,-0.00635,6.35e-06,False +0.5,-0.03054,3.054e-05,False diff --git a/notebooks/data/20240930/3p5mMEDTAto50uMaA2A4.csv b/notebooks/data/20240930/3p5mMEDTAto50uMaA2A4.csv new file mode 100644 index 0000000..d9e4b2a --- /dev/null +++ b/notebooks/data/20240930/3p5mMEDTAto50uMaA2A4.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-48.50977,0.04850977000000001,True +1.5001,-64.43071,0.06443071,False +1.5001,-65.30908,0.06530907999999999,False +1.5001,-65.03231,0.06503231,False +1.5001,-67.33676,0.06733676,False +1.5001,-65.65482,0.06565482,False +1.5001,-66.36707,0.06636707,False +1.5001,-67.28166,0.06728166000000001,False +1.5001,-67.56955,0.06756955,False +1.5001,-67.66913,0.06766913,False +1.5001,-66.49325,0.06649325,False +1.5001,-66.34292,0.06634292000000001,False +1.5001,-66.41333,0.06641333,False +1.5001,-66.44606,0.06644606,False +1.5001,-65.96095,0.06596095,False +1.5001,-63.98694,0.06398693999999999,False +0.5001,-21.21301,0.02121301,False +0.5001,-21.36218,0.021362179999999998,False +0.5001,-21.58161,0.02158161,False +0.5001,-21.27026,0.02127026,False +0.5001,-21.23368,0.02123368,False +0.5001,-21.0174,0.0210174,False +0.5001,-20.68321,0.02068321,False +0.5001,-18.10374,0.01810374,False +0.5001,-9.21571,0.00921571,False +0.5001,-2.1774,0.0021774,False +0.5001,-0.64697,0.0006469700000000001,False +0.5001,-0.20461,0.00020460999999999998,False +0.5001,-0.11858,0.00011858,False +0.5001,-0.06531,6.531000000000001e-05,False +0.5001,0.06477,6.476999999999999e-05,False +0.5001,0.09253,9.253e-05,False +0.5001,0.14763,0.00014763000000000002,False +0.5001,0.08379,8.379000000000001e-05,False +0.5001,0.04387,4.387e-05,False +0.5001,0.08993,8.993e-05,False +0.5001,0.01981,1.9810000000000002e-05,False +0.5001,0.03992,3.992e-05,False +0.5001,0.11297,0.00011297,False +0.5001,-0.04322,4.322e-05,False +0.5001,0.02671,2.671e-05,False +0.5001,0.1474,0.0001474,False +0.5001,0.15421,0.00015421000000000003,False diff --git a/notebooks/data/20240930/3p5mMEDTAto50uMaA2A4v2.csv b/notebooks/data/20240930/3p5mMEDTAto50uMaA2A4v2.csv new file mode 100644 index 0000000..923e753 --- /dev/null +++ b/notebooks/data/20240930/3p5mMEDTAto50uMaA2A4v2.csv @@ -0,0 +1,74 @@ +injection,heat,heat_stdev,ignore_point +2.35,-49.59749,0.04959749,True +0.5,-21.34054,0.02134054,False +0.5,-21.86665,0.02186665,False +0.5,-22.10415,0.02210415,False +0.5,-22.32792,0.022327919999999998,False +0.5,-22.33541,0.02233541,False +0.5,-22.18645,0.02218645,False +0.5,-22.34811,0.022348109999999997,False +0.5,-19.48257,0.01948257,False +0.5,-24.93547,0.024935469999999998,False +0.5,-22.39185,0.02239185,False +0.5,-22.25311,0.02225311,False +0.5,-22.43612,0.02243612,False +0.5,-22.2372,0.022237200000000002,False +0.5,-22.00466,0.022004660000000002,False +0.5,-22.11685,0.02211685,False +0.5,-21.89338,0.02189338,False +0.5,-21.9061,0.021906099999999998,False +0.5,-21.9838,0.021983799999999998,False +0.5,-22.33347,0.022333469999999998,False +0.5,-22.19408,0.02219408,False +0.5,-22.20799,0.02220799,False +0.5,-22.00436,0.022004359999999997,False +0.5,-21.96586,0.02196586,False +0.5,-22.29923,0.022299230000000003,False +0.5,-22.21428,0.02221428,False +0.5,-22.33787,0.02233787,False +0.5,-22.27163,0.022271629999999997,False +0.5,-22.12765,0.02212765,False +0.5,-21.83974,0.02183974,False +0.5,-21.99465,0.02199465,False +0.5,-21.84102,0.02184102,False +0.5,-21.56307,0.02156307,False +0.5,-21.81498,0.021814979999999998,False +0.5,-22.32395,0.022323950000000002,False +0.5,-21.92587,0.02192587,False +0.5,-21.95112,0.02195112,False +0.5,-22.1569,0.0221569,False +0.5,-21.95504,0.021955040000000002,False +0.5,-21.60769,0.021607690000000002,False +0.5,-21.98677,0.02198677,False +0.5,-21.8061,0.021806100000000002,False +0.5,-21.99,0.02199,False +0.5,-21.57843,0.021578430000000003,False +0.5,-21.45512,0.02145512,False +0.5,-21.50151,0.02150151,False +0.5,-21.47255,0.02147255,False +0.5,-21.75914,0.02175914,False +0.5,-21.66123,0.02166123,False +0.5,-21.69118,0.02169118,False +0.5,-21.41073,0.021410730000000003,False +0.5,-21.35865,0.02135865,False +0.5,-21.10184,0.02110184,False +0.5,-19.77885,0.01977885,False +0.5,-14.17516,0.014175160000000001,False +0.5,-4.48494,0.00448494,False +0.5,-0.88871,0.00088871,False +0.5,-0.83547,0.00083547,False +0.5,-0.22905,0.00022905,False +0.5,-0.14343,0.00014343,False +0.5,-0.08183,8.183000000000001e-05,False +0.5,0.10603,0.00010603,False +0.5,0.04486,4.486e-05,False +0.5,0.0833,8.33e-05,False +0.5,0.14542,0.00014542,False +0.5,0.00724,7.24e-06,False +0.5,-0.0173,1.73e-05,False +0.5,0.05187,5.187e-05,False +0.5,0.03015,3.015e-05,False +0.5,0.11149,0.00011149,False +0.5,-0.00309,3.09e-06,False +0.5,0.04877,4.877e-05,False +0.5,-0.11026,0.00011026,False diff --git a/notebooks/data/20241001/3mMEDTAto500uMCa.csv b/notebooks/data/20241001/3mMEDTAto500uMCa.csv new file mode 100644 index 0000000..fda2322 --- /dev/null +++ b/notebooks/data/20241001/3mMEDTAto500uMCa.csv @@ -0,0 +1,44 @@ +injection,heat,heat_stdev,ignore_point +2.35,-43.55239,0.04355239,True +1.5001,-55.15164,0.05515164,False +1.5001,-55.24487,0.05524487,False +1.5001,-55.11563,0.055115630000000006,False +1.5001,-52.6072,0.0526072,False +1.5001,-55.83644,0.05583644,False +1.5001,-54.91872,0.054918720000000004,False +1.5001,-55.06646,0.05506646,False +1.5001,-55.40612,0.05540612,False +1.5001,-55.7207,0.055720700000000005,False +1.5001,-55.19716,0.055197159999999995,False +1.5001,-54.87701,0.05487701,False +1.5001,-54.82708,0.05482708,False +1.5001,-54.7709,0.0547709,False +1.5001,-54.71221,0.05471221,False +1.5001,-54.40994,0.05440994,False +0.5001,-17.93324,0.017933240000000003,False +0.5001,-17.89662,0.01789662,False +0.5001,-17.85996,0.01785996,False +0.5001,-17.79867,0.017798670000000003,False +0.5001,-17.78522,0.01778522,False +0.5001,-17.73078,0.017730779999999998,False +0.5001,-17.80013,0.01780013,False +0.5001,-17.52538,0.01752538,False +0.5001,-17.28763,0.017287630000000002,False +0.5001,-16.42499,0.01642499,False +0.5001,-13.54416,0.01354416,False +0.5001,-5.9964,0.005996400000000001,False +0.5001,-1.48915,0.00148915,False +0.5001,-0.56002,0.0005600199999999999,False +0.5001,-0.30253,0.00030253,False +0.5001,-0.18791,0.00018791,False +0.5001,-0.09908,9.908000000000001e-05,False +0.5001,-0.09056,9.056e-05,False +0.5001,-0.07653,7.653e-05,False +0.5001,0.00793,7.93e-06,False +0.5001,-0.03339,3.3390000000000004e-05,False +0.5001,-0.04315,4.315e-05,False +0.5001,0.0484,4.84e-05,False +0.5001,-0.04435,4.435e-05,False +0.5001,-0.01707,1.7069999999999998e-05,False +0.5001,-0.05095,5.0950000000000005e-05,False +0.5001,-0.03682,3.6819999999999996e-05,False diff --git a/notebooks/data/20241001/3p5mMEDTAto500uMCaCl2HHR.csv b/notebooks/data/20241001/3p5mMEDTAto500uMCaCl2HHR.csv new file mode 100644 index 0000000..f6cd343 --- /dev/null +++ b/notebooks/data/20241001/3p5mMEDTAto500uMCaCl2HHR.csv @@ -0,0 +1,146 @@ +injection,heat,heat_stdev,ignore_point +2.35,-43.89886,0.04389886,True +0.25,-10.21459,0.010214589999999999,False +0.25,-10.91355,0.010913550000000001,False +0.25,-10.57564,0.01057564,False +0.25,-10.95072,0.01095072,False +0.25,-10.684,0.010683999999999999,False +0.25,-10.79304,0.01079304,False +0.25,-10.884,0.010884000000000001,False +0.25,-10.75936,0.010759359999999999,False +0.25,-11.03719,0.01103719,False +0.25,-10.70044,0.01070044,False +0.25,-11.22392,0.01122392,False +0.25,-10.52205,0.01052205,False +0.25,-11.23717,0.011237170000000001,False +0.25,-10.56879,0.01056879,False +0.25,-11.28411,0.01128411,False +0.25,-10.63834,0.01063834,False +0.25,-11.07055,0.01107055,False +0.25,-10.74381,0.01074381,False +0.25,-10.99737,0.010997370000000001,False +0.25,-10.88336,0.01088336,False +0.25,-10.8602,0.0108602,False +0.25,-11.06786,0.01106786,False +0.25,-10.97733,0.01097733,False +0.25,-11.23683,0.01123683,False +0.25,-10.70784,0.01070784,False +0.25,-11.33469,0.01133469,False +0.25,-10.64841,0.01064841,False +0.25,-11.38953,0.01138953,False +0.25,-10.65955,0.01065955,False +0.25,-11.27584,0.01127584,False +0.25,-10.78322,0.01078322,False +0.25,-11.11713,0.01111713,False +0.25,-10.91715,0.01091715,False +0.25,-10.98112,0.01098112,False +0.25,-11.09485,0.01109485,False +0.25,-10.78088,0.01078088,False +0.25,-11.2338,0.0112338,False +0.25,-10.6311,0.010631100000000001,False +0.25,-11.32088,0.01132088,False +0.25,-10.59582,0.01059582,False +0.25,-11.34096,0.01134096,False +0.25,-10.55981,0.010559810000000001,False +0.25,-11.17933,0.011179330000000001,False +0.25,-10.50247,0.010502470000000002,False +0.25,-11.04745,0.01104745,False +0.25,-10.70941,0.01070941,False +0.25,-10.93638,0.01093638,False +0.25,-11.02829,0.01102829,False +0.25,-10.71243,0.01071243,False +0.25,-11.20926,0.01120926,False +0.25,-10.6517,0.0106517,False +0.25,-11.26267,0.01126267,False +0.25,-10.48944,0.010489440000000001,False +0.25,-11.35968,0.01135968,False +0.25,-10.47231,0.01047231,False +0.25,-11.29349,0.01129349,False +0.25,-10.43387,0.010433870000000001,False +0.25,-11.26095,0.011260949999999999,False +0.25,-10.62759,0.01062759,False +0.25,-11.05907,0.01105907,False +0.25,-10.91205,0.010912050000000001,False +0.25,-10.86178,0.01086178,False +0.25,-11.04628,0.01104628,False +0.25,-10.82976,0.01082976,False +0.25,-11.2538,0.0112538,False +0.25,-10.56978,0.010569779999999999,False +0.25,-11.26017,0.01126017,False +0.25,-10.51779,0.01051779,False +0.25,-11.15772,0.01115772,False +0.25,-10.55953,0.010559530000000001,False +0.25,-10.96708,0.010967079999999999,False +0.25,-10.71915,0.01071915,False +0.25,-10.87244,0.010872439999999999,False +0.25,-10.94924,0.01094924,False +0.25,-10.78534,0.01078534,False +0.25,-10.98084,0.01098084,False +0.25,-10.588,0.010588,False +0.25,-11.06168,0.01106168,False +0.25,-10.54021,0.01054021,False +0.25,-11.02931,0.01102931,False +0.25,-10.22185,0.01022185,False +0.25,-10.79043,0.01079043,False +0.25,-9.74739,0.00974739,False +0.25,-9.28382,0.00928382,False +0.25,-6.24877,0.006248770000000001,False +0.25,-3.0099,0.0030099000000000002,False +0.25,-1.11983,0.00111983,False +0.25,-0.58395,0.00058395,False +0.25,-0.34117,0.00034116999999999996,False +0.25,-0.16826,0.00016826,False +0.25,-0.01805,1.805e-05,False +0.25,-0.05897,5.897e-05,False +0.25,-0.08674,8.674e-05,False +0.25,-0.12048,0.00012048000000000001,False +0.25,-0.16195,0.00016195,False +0.25,-0.32127,0.00032127,False +0.25,-0.10925,0.00010925,False +0.25,0.81616,0.00081616,False +0.25,-0.99133,0.0009913300000000001,False +0.25,-0.11472,0.00011472,False +0.25,-0.03697,3.697000000000001e-05,False +0.25,0.29547,0.00029547000000000004,False +0.25,0.13741,0.00013741,False +0.25,0.46813,0.00046813,False +0.25,-0.03789,3.789e-05,False +0.25,-0.10578,0.00010578000000000001,False +0.25,0.09266,9.266000000000001e-05,False +0.25,-0.10367,0.00010367,False +0.25,-0.14305,0.00014305,False +0.25,-0.09277,9.277000000000001e-05,False +0.25,0.05596,5.5960000000000006e-05,False +0.25,0.0246,2.46e-05,False +0.25,-0.05372,5.372e-05,False +0.25,0.13765,0.00013764999999999998,False +0.25,0.09171,9.171e-05,False +0.25,0.00446,4.4600000000000005e-06,False +0.25,0.15602,0.00015602,False +0.25,-0.0336,3.36e-05,False +0.25,-0.03258,3.2579999999999996e-05,False +0.25,-0.02395,2.395e-05,False +0.25,-0.02636,2.6360000000000002e-05,False +0.25,0.06548,6.548e-05,False +0.25,0.05785,5.785e-05,False +0.25,0.2336,0.0002336,False +0.25,0.07628,7.628000000000001e-05,False +0.25,-0.01704,1.704e-05,False +0.25,0.02786,2.786e-05,False +0.25,0.0051,5.1e-06,False +0.25,0.02739,2.739e-05,False +0.25,-0.08663,8.663e-05,False +0.25,-0.09914,9.914e-05,False +0.25,0.07261,7.261e-05,False +0.25,-0.11907,0.00011907,False +0.25,0.03747,3.7470000000000005e-05,False +0.25,-0.00435,4.35e-06,False +0.25,0.05881,5.881e-05,False +0.25,-0.06901,6.901e-05,False +0.25,-0.05697,5.697e-05,False +0.25,-0.00632,6.3200000000000005e-06,False +0.25,0.0417,4.1700000000000004e-05,False +0.25,0.06359,6.358999999999999e-05,False +0.25,0.02614,2.614e-05,False +0.25,-0.09183,9.183e-05,False +0.25,0.05069,5.069e-05,False diff --git a/notebooks/data/20241001/3p5mMEDTAto50uMaA2A4.csv b/notebooks/data/20241001/3p5mMEDTAto50uMaA2A4.csv new file mode 100644 index 0000000..f3c843b --- /dev/null +++ b/notebooks/data/20241001/3p5mMEDTAto50uMaA2A4.csv @@ -0,0 +1,74 @@ +injection,heat,heat_stdev,ignore_point +2.35,-48.82813,0.048828130000000004,True +0.5,-22.02949,0.02202949,False +0.5,-22.42009,0.02242009,False +0.5,-21.72348,0.02172348,False +0.5,-22.54832,0.02254832,False +0.5,-23.20559,0.02320559,False +0.5,-17.56929,0.017569289999999998,False +0.5,-22.70998,0.02270998,False +0.5,-22.51763,0.02251763,False +0.5,-22.49272,0.022492719999999997,False +0.5,-22.65148,0.022651479999999998,False +0.5,-22.67132,0.022671320000000002,False +0.5,-22.83332,0.02283332,False +0.5,-22.62315,0.022623149999999998,False +0.5,-22.7144,0.022714400000000003,False +0.5,-22.75396,0.02275396,False +0.5,-22.44964,0.02244964,False +0.5,-22.41289,0.02241289,False +0.5,-22.67338,0.022673380000000003,False +0.5,-22.85386,0.02285386,False +0.5,-23.00956,0.023009560000000002,False +0.5,-22.89396,0.02289396,False +0.5,-22.34921,0.02234921,False +0.5,-22.29936,0.02229936,False +0.5,-22.35141,0.022351410000000002,False +0.5,-20.58017,0.02058017,False +0.5,-22.53469,0.022534690000000003,False +0.5,-22.3503,0.0223503,False +0.5,-22.33988,0.022339880000000003,False +0.5,-22.14343,0.02214343,False +0.5,-22.10095,0.02210095,False +0.5,-22.20966,0.02220966,False +0.5,-22.28186,0.02228186,False +0.5,-22.16233,0.02216233,False +0.5,-22.08822,0.02208822,False +0.5,-22.0197,0.0220197,False +0.5,-21.89448,0.02189448,False +0.5,-21.90718,0.021907180000000002,False +0.5,-21.89084,0.02189084,False +0.5,-21.98335,0.021983350000000002,False +0.5,-22.04546,0.02204546,False +0.5,-21.66906,0.021669060000000004,False +0.5,-21.71155,0.02171155,False +0.5,-21.40199,0.021401990000000003,False +0.5,-21.30376,0.02130376,False +0.5,-21.3454,0.0213454,False +0.5,-21.02105,0.02102105,False +0.5,-18.9886,0.0189886,False +0.5,-9.89016,0.00989016,False +0.5,-2.35152,0.0023515199999999997,False +0.5,-0.66187,0.00066187,False +0.5,-0.21404,0.00021404,False +0.5,-0.06835,6.835e-05,False +0.5,-0.06223,6.223e-05,False +0.5,-0.1185,0.0001185,False +0.5,-0.04138,4.138e-05,False +0.5,-0.02402,2.402e-05,False +0.5,0.06282,6.282e-05,False +0.5,-0.05656,5.656e-05,False +0.5,0.01076,1.076e-05,False +0.5,0.05075,5.075000000000001e-05,False +0.5,0.17266,0.00017266000000000002,False +0.5,0.02073,2.073e-05,False +0.5,-0.07931,7.931000000000001e-05,False +0.5,-0.08667,8.667e-05,False +0.5,-0.03838,3.8379999999999995e-05,False +0.5,-0.05783,5.783e-05,False +0.5,0.08598,8.598e-05,False +0.5,0.07071,7.070999999999999e-05,False +0.5,0.1363,0.0001363,False +0.5,0.15037,0.00015037,False +0.5,0.1052,0.00010520000000000001,False +0.5,0.12398,0.00012398000000000002,False diff --git a/notebooks/data/itc_binding_expt.csv b/notebooks/data/itc_binding_expt.csv index 1f6e252..48db73b 100644 --- a/notebooks/data/itc_binding_expt.csv +++ b/notebooks/data/itc_binding_expt.csv @@ -1,44 +1,44 @@ -injection,obs_heat,std_heat,ignore_point -2.35e-6,-43.55239e-6,0.01,True -1.5001e-6,-55.15164e-6,0.01,False -1.5001e-6,-55.24487e-6,0.01,False -1.5001e-6,-55.11563e-6,0.01,False -1.5001e-6,-52.6072e-6,0.01,False -1.5001e-6,-55.83644e-6,0.01,False -1.5001e-6,-54.91872e-6,0.01,False -1.5001e-6,-55.06646e-6,0.01,False -1.5001e-6,-55.40612e-6,0.01,False -1.5001e-6,-55.7207e-6,0.01,False -1.5001e-6,-55.19716e-6,0.01,False -1.5001e-6,-54.87701e-6,0.01,False -1.5001e-6,-54.82708e-6,0.01,False -1.5001e-6,-54.7709e-6,0.01,False -1.5001e-6,-54.71221e-6,0.01,False -1.5001e-6,-54.40994e-6,0.01,False -0.5001e-6,-17.93324e-6,0.01,False -0.5001e-6,-17.89662e-6,0.01,False -0.5001e-6,-17.85996e-6,0.01,False -0.5001e-6,-17.79867e-6,0.01,False -0.5001e-6,-17.78522e-6,0.01,False -0.5001e-6,-17.73078e-6,0.01,False -0.5001e-6,-17.80013e-6,0.01,False -0.5001e-6,-17.52538e-6,0.01,False -0.5001e-6,-17.28763e-6,0.01,False -0.5001e-6,-16.42499e-6,0.01,False -0.5001e-6,-13.54416e-6,0.01,False -0.5001e-6,-5.9964e-6,0.01,False -0.5001e-6,-1.48915e-6,0.01,False -0.5001e-6,-0.56002e-6,0.01,False -0.5001e-6,-0.30253e-6,0.01,False -0.5001e-6,-0.18791e-6,0.01,False -0.5001e-6,-0.09908e-6,0.01,False -0.5001e-6,-0.09056e-6,0.01,False -0.5001e-6,-0.07653e-6,0.01,False -0.5001e-6,0.00793e-6,0.01,False -0.5001e-6,-0.03339e-6,0.01,False -0.5001e-6,-0.04315e-6,0.01,False -0.5001e-6,0.0484e-6,0.01,False -0.5001e-6,-0.04435e-6,0.01,False -0.5001e-6,-0.01707e-6,0.01,False -0.5001e-6,-0.05095e-6,0.01,False -0.5001e-6,-0.03682e-6,0.01,False +injection,obs_heat,std_heat,ignore_point,heat_stdev +2.35e-06,-4.355239e-05,0.01,True,0.1 +1.5001e-06,-5.515164e-05,0.01,False,0.1 +1.5001e-06,-5.524487e-05,0.01,False,0.1 +1.5001e-06,-5.511563e-05,0.01,False,0.1 +1.5001e-06,-5.26072e-05,0.01,False,0.1 +1.5001e-06,-5.583644e-05,0.01,False,0.1 +1.5001e-06,-5.491872e-05,0.01,False,0.1 +1.5001e-06,-5.506646e-05,0.01,False,0.1 +1.5001e-06,-5.540612e-05,0.01,False,0.1 +1.5001e-06,-5.57207e-05,0.01,False,0.1 +1.5001e-06,-5.519716e-05,0.01,False,0.1 +1.5001e-06,-5.487701e-05,0.01,False,0.1 +1.5001e-06,-5.482708e-05,0.01,False,0.1 +1.5001e-06,-5.47709e-05,0.01,False,0.1 +1.5001e-06,-5.471221e-05,0.01,False,0.1 +1.5001e-06,-5.440994e-05,0.01,False,0.1 +5.001e-07,-1.793324e-05,0.01,False,0.1 +5.001e-07,-1.789662e-05,0.01,False,0.1 +5.001e-07,-1.785996e-05,0.01,False,0.1 +5.001e-07,-1.779867e-05,0.01,False,0.1 +5.001e-07,-1.778522e-05,0.01,False,0.1 +5.001e-07,-1.773078e-05,0.01,False,0.1 +5.001e-07,-1.780013e-05,0.01,False,0.1 +5.001e-07,-1.752538e-05,0.01,False,0.1 +5.001e-07,-1.728763e-05,0.01,False,0.1 +5.001e-07,-1.642499e-05,0.01,False,0.1 +5.001e-07,-1.354416e-05,0.01,False,0.1 +5.001e-07,-5.9964e-06,0.01,False,0.1 +5.001e-07,-1.48915e-06,0.01,False,0.1 +5.001e-07,-5.6002e-07,0.01,False,0.1 +5.001e-07,-3.0253e-07,0.01,False,0.1 +5.001e-07,-1.8791e-07,0.01,False,0.1 +5.001e-07,-9.908e-08,0.01,False,0.1 +5.001e-07,-9.056e-08,0.01,False,0.1 +5.001e-07,-7.653e-08,0.01,False,0.1 +5.001e-07,7.93e-09,0.01,False,0.1 +5.001e-07,-3.339e-08,0.01,False,0.1 +5.001e-07,-4.315e-08,0.01,False,0.1 +5.001e-07,4.84e-08,0.01,False,0.1 +5.001e-07,-4.435e-08,0.01,False,0.1 +5.001e-07,-1.707e-08,0.01,False,0.1 +5.001e-07,-5.095e-08,0.01,False,0.1 +5.001e-07,-3.682e-08,0.01,False,0.1 diff --git a/notebooks/data/itc_blank_expt.csv b/notebooks/data/itc_blank_expt.csv index 7d6cfb7..a23c3cc 100644 --- a/notebooks/data/itc_blank_expt.csv +++ b/notebooks/data/itc_blank_expt.csv @@ -1,26 +1,26 @@ -injection,obs_heat,heat_std,ignore_point -2.35e-6,-1.7491e-6,0,True -1.5e-6,0.08709e-6,0,False -1.5e-6,-0.05587e-6,0,False -1.5e-6,0.01021e-6,0,False -1.5e-6,1.75655e-6,0,False -1.5e-6,-1.86322e-6,0,False -1.5e-6,-0.01909e-6,0,False -1.5e-6,-0.09784e-6,0,False -1.5e-6,-0.14389e-6,0,False -1.5e-6,-0.17952e-6,0,False -1.5e-6,-0.09946e-6,0,False -1.5e-6,-0.01915e-6,0,False -1.5e-6,-0.02182e-6,0,False -1.5e-6,-0.03853e-6,0,False -1.5e-6,-0.03838e-6,0,False -1.5e-6,-0.0531e-6,0,False -1.5e-6,-0.05101e-6,0,False -1.5e-6,-0.07015e-6,0,False -1.5e-6,-0.02583e-6,0,False -1.5e-6,0.00199e-6,0,False -1.5e-6,-0.01206e-6,0,False -1.5e-6,-0.08337e-6,0,False -1.5e-6,-0.08477e-6,0,False -1.5e-6,-0.01629e-6,0,False -1.5e-6,-0.05862e-6,0,False +injection,obs_heat,heat_std,ignore_point,heat_stdev +2.35e-06,-1.7491e-06,0,True,0.1 +1.5e-06,8.709e-08,0,False,0.1 +1.5e-06,-5.587e-08,0,False,0.1 +1.5e-06,1.021e-08,0,False,0.1 +1.5e-06,1.75655e-06,0,False,0.1 +1.5e-06,-1.86322e-06,0,False,0.1 +1.5e-06,-1.909e-08,0,False,0.1 +1.5e-06,-9.784e-08,0,False,0.1 +1.5e-06,-1.4389e-07,0,False,0.1 +1.5e-06,-1.7952e-07,0,False,0.1 +1.5e-06,-9.946e-08,0,False,0.1 +1.5e-06,-1.915e-08,0,False,0.1 +1.5e-06,-2.182e-08,0,False,0.1 +1.5e-06,-3.853e-08,0,False,0.1 +1.5e-06,-3.838e-08,0,False,0.1 +1.5e-06,-5.31e-08,0,False,0.1 +1.5e-06,-5.101e-08,0,False,0.1 +1.5e-06,-7.015e-08,0,False,0.1 +1.5e-06,-2.583e-08,0,False,0.1 +1.5e-06,1.99e-09,0,False,0.1 +1.5e-06,-1.206e-08,0,False,0.1 +1.5e-06,-8.337e-08,0,False,0.1 +1.5e-06,-8.477e-08,0,False,0.1 +1.5e-06,-1.629e-08,0,False,0.1 +1.5e-06,-5.862e-08,0,False,0.1 diff --git a/notebooks/genericmodelimplementation_6state+TMAO.ipynb b/notebooks/genericmodelimplementation_6state+TMAO.ipynb new file mode 100644 index 0000000..c30199c --- /dev/null +++ b/notebooks/genericmodelimplementation_6state+TMAO.ipynb @@ -0,0 +1,2506 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b11cea11-6bb7-4286-9550-6a47f3c017ad", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import dataprob\n", + "import copy\n", + "import linkage" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0f514d5b-494b-4640-b6ad-d4b94a939070", + "metadata": {}, + "outputs": [], + "source": [ + "### Global-ish Variables\n", + "\n", + "cell_vol = 201.3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "75839bf7-0265-4c1b-9bdb-770c1d2fb2f1", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## Experiment loading template\n", + "\n", + "## CD Experiments\n", + "\n", + "# experiment = linkage.experiment.Experiment(r\"location of file\",\n", + "# cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + "# syringe_contents={\"ET\":2e-3},\n", + "# cell_volume=cell_vol,\n", + "# conc_to_float=\"ET\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e3dcd871-2c9f-45e2-9212-4b02e0c9c356", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "## EDTA --> Protein + Ca\n", + "prot1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4HIGHRES.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "prot2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4SUPERDUPERRES.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "prot3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240823\\3mMEDTAto50uMhA4.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot3.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "prot4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA4.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot4.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "prot5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA42.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot5.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "prot6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA43.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot6.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aa5859dd-5f12-4e69-a23b-3e4ce1f92ded", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "## Ca -> EDTA + Protein\n", + "\n", + "reprot1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA50uMhA4.csv\",\n", + " cell_contents={\"ET\":50e-6, \"AT\":25e-6},\n", + " syringe_contents={\"CT\":500e-6},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "reprot1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "reprot2 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCato50uMEDTA50uMhA4.csv\",\n", + " cell_contents={\"ET\":50e-6, \"AT\":25e-6},\n", + " syringe_contents={\"CT\":1e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "reprot2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "13142c7a-d93f-4854-8cf1-115d1ffd1416", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "## EDTA --> Buffer\n", + "\n", + "blank1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa2.csv\",\n", + " cell_contents={\"CT\":0},\n", + " syringe_contents={\"ET\":4e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "blank1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "blank2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa3.csv\",\n", + " cell_contents={\"CT\":0},\n", + " syringe_contents={\"ET\":4e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "blank2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "de27fe29-4552-471f-ad26-56cf8e14a858", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "## Ca --> Buffer\n", + "\n", + "blank3 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer.csv\",\n", + " cell_contents={},\n", + " syringe_contents={\"CT\":1e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"CT\")\n", + "blank3.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "blank4 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer2.csv\",\n", + " cell_contents={},\n", + " syringe_contents={\"CT\":1e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"CT\")\n", + "blank4.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d7fa5620-857a-4b69-bfd5-c1ec5fdb14a6", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "## Ca --> EDTA\n", + "\n", + "caedta1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA.csv\",\n", + " cell_contents={\"ET\":50e-6},\n", + " syringe_contents={\"CT\":500e-6},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "caedta1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ab6dd4a3-bd7d-41fb-9591-ee9cb9f97b43", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "## EDTA --> Ca\n", + "\n", + "edtaca1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3mMEDTAto500uMCa.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "edtaca2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3p5mMEDTAto500uMCaCl2HHR.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "edtaca3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240915\\3p5mMEDTAto500uMCaCl2lowres.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca3.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "edtaca4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto500uMCaLOWRES.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca4.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "edtaca5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca5.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "edtaca6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_2.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca6.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "edtaca7 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_3.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca7.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "973ecc70-baf0-4fc2-a25a-047d67b0da51", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===== GENERIC BINDING MODEL SUMMARY =====\n", + "Constants (parameters to fit as ln(K)): ['KE', 'KM', 'KI', 'K1', 'K2', 'K3', 'K4']\n", + "Microspecies: ['A', 'AC1', 'AC2', 'AC3', 'AC4', 'C', 'E', 'EC', 'I', 'M']\n", + "Macrospecies (total concentrations): ['AT', 'CT', 'ET', 'MT']\n", + "Equilibria:\n", + " C + E -> EC; KE\n", + " A + M -> I; KM\n", + " I -> A; KI\n", + " A + C -> AC1; K1\n", + " AC1 + C -> AC2; K2\n", + " AC2 + C -> AC3; K3\n", + " AC3 + C -> AC4; K4\n", + "\n", + "Symbolic final conservation equation (set to 0): (2*AT*C*K1*(C*KE + 1)*(2*C**3*K2*K3*K4 + 3*C**2*K2*K3 + C*K2 + 1) + C*ET*KE*(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI*KM*M + KM*M) + (C - CT)*(C*KE + 1)*(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI*KM*M + KM*M))/((C*KE + 1)*(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI*KM*M + KM*M))\n", + "Lambdified function for final conservation equation created for fallback root finding.\n", + " Expected non-C args for lambdified func: ['AT', 'CT', 'ET', 'K1', 'K2', 'K3', 'K4', 'KE', 'KI', 'KM', 'M']\n", + "Final conservation equation IS NOT a simple polynomial in C (after other substitutions). Will use numerical root finding.\n", + "===== END SUMMARY =====\n", + "\n" + ] + } + ], + "source": [ + "#### Create model instance\n", + "#Full Lists\n", + "blank_list = [blank1, blank2]\n", + "edtaca_list = [edtaca1, edtaca2, edtaca3, edtaca4, edtaca5, edtaca6, edtaca7, caedta1]\n", + "prot_list = [prot1, prot2, prot3, prot4, prot5, prot6]#, reprot1, reprot2]\n", + "\n", + "#Combine experiment types into one list\n", + "expt_list = blank_list + edtaca_list + prot_list\n", + "\n", + "\n", + "# Read the model specification from file\n", + "spec_file_path = r\"C:\\Users\\willi\\linkage\\src\\linkage\\model_specs\\SixStateEDTA+TMAO.txt\"\n", + "\n", + "# Read spec\n", + "with open(spec_file_path, 'r') as f:\n", + " model_spec = f.read()\n", + "\n", + "# Create GlobalModel with spec\n", + "gm = linkage.GlobalModel(\n", + " model_name=\"GenericBindingModel\",\n", + " model_spec=model_spec,\n", + " expt_list=expt_list\n", + ")\n", + "\n", + "#Setup dataprob\n", + "f = dataprob.setup(gm.model_normalized,\n", + " method=\"ml\",\n", + " vector_first_arg=True,\n", + " fit_parameters=gm.parameter_names)\n", + "\n", + "# Access the binding model through the GlobalModel\n", + "gm._bm.print_summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "10064dc1-cb03-4ea7-b107-2dba82d6ba2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE0.0False-infinfNaNNaN
KMKM0.0False-infinfNaNNaN
KIKI0.0False-infinfNaNNaN
K1K10.0False-infinfNaNNaN
K2K20.0False-infinfNaNNaN
K3K30.0False-infinfNaNNaN
K4K40.0False-infinfNaNNaN
dH_EdH_E0.0False-infinfNaNNaN
dH_MdH_M0.0False-infinfNaNNaN
dH_IdH_I0.0False-infinfNaNNaN
dH_1dH_10.0False-infinfNaNNaN
dH_2dH_20.0False-infinfNaNNaN
dH_3dH_30.0False-infinfNaNNaN
dH_4dH_40.0False-infinfNaNNaN
nuisance_dil_CTnuisance_dil_CT0.0False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ET0.0False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_10_ET_fudgenuisance_expt_10_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_11_ET_fudgenuisance_expt_11_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_12_ET_fudgenuisance_expt_12_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_13_ET_fudgenuisance_expt_13_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_14_ET_fudgenuisance_expt_14_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_15_ET_fudgenuisance_expt_15_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_16_ET_fudgenuisance_expt_16_ET_fudge0.0False-infinfNaNNaN
\n", + "
" + ], + "text/plain": [ + " name guess fixed \\\n", + "name \n", + "KE KE 0.0 False \n", + "KM KM 0.0 False \n", + "KI KI 0.0 False \n", + "K1 K1 0.0 False \n", + "K2 K2 0.0 False \n", + "K3 K3 0.0 False \n", + "K4 K4 0.0 False \n", + "dH_E dH_E 0.0 False \n", + "dH_M dH_M 0.0 False \n", + "dH_I dH_I 0.0 False \n", + "dH_1 dH_1 0.0 False \n", + "dH_2 dH_2 0.0 False \n", + "dH_3 dH_3 0.0 False \n", + "dH_4 dH_4 0.0 False \n", + "nuisance_dil_CT nuisance_dil_CT 0.0 False \n", + "nuisance_dil_ET nuisance_dil_ET 0.0 False \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge 0.0 False \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge 0.0 False \n", + "nuisance_expt_2_ET_fudge nuisance_expt_2_ET_fudge 0.0 False \n", + "nuisance_expt_3_ET_fudge nuisance_expt_3_ET_fudge 0.0 False \n", + "nuisance_expt_4_ET_fudge nuisance_expt_4_ET_fudge 0.0 False \n", + "nuisance_expt_5_ET_fudge nuisance_expt_5_ET_fudge 0.0 False \n", + "nuisance_expt_6_ET_fudge nuisance_expt_6_ET_fudge 0.0 False \n", + "nuisance_expt_7_ET_fudge nuisance_expt_7_ET_fudge 0.0 False \n", + "nuisance_expt_8_ET_fudge nuisance_expt_8_ET_fudge 0.0 False \n", + "nuisance_expt_9_ET_fudge nuisance_expt_9_ET_fudge 0.0 False \n", + "nuisance_expt_10_ET_fudge nuisance_expt_10_ET_fudge 0.0 False \n", + "nuisance_expt_11_ET_fudge nuisance_expt_11_ET_fudge 0.0 False \n", + "nuisance_expt_12_ET_fudge nuisance_expt_12_ET_fudge 0.0 False \n", + "nuisance_expt_13_ET_fudge nuisance_expt_13_ET_fudge 0.0 False \n", + "nuisance_expt_14_ET_fudge nuisance_expt_14_ET_fudge 0.0 False \n", + "nuisance_expt_15_ET_fudge nuisance_expt_15_ET_fudge 0.0 False \n", + "nuisance_expt_16_ET_fudge nuisance_expt_16_ET_fudge 0.0 False \n", + "\n", + " lower_bound upper_bound prior_mean prior_std \n", + "name \n", + "KE -inf inf NaN NaN \n", + "KM -inf inf NaN NaN \n", + "KI -inf inf NaN NaN \n", + "K1 -inf inf NaN NaN \n", + "K2 -inf inf NaN NaN \n", + "K3 -inf inf NaN NaN \n", + "K4 -inf inf NaN NaN \n", + "dH_E -inf inf NaN NaN \n", + "dH_M -inf inf NaN NaN \n", + "dH_I -inf inf NaN NaN \n", + "dH_1 -inf inf NaN NaN \n", + "dH_2 -inf inf NaN NaN \n", + "dH_3 -inf inf NaN NaN \n", + "dH_4 -inf inf NaN NaN \n", + "nuisance_dil_CT -inf inf NaN NaN \n", + "nuisance_dil_ET -inf inf NaN NaN \n", + "nuisance_expt_0_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_1_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_2_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_3_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_4_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_5_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_6_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_7_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_8_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_9_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_10_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_11_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_12_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_13_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_14_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_15_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_16_ET_fudge -inf inf NaN NaN " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.param_df" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a8e9c307-8be7-4bbc-a6ce-d26c5137978a", + "metadata": {}, + "outputs": [], + "source": [ + "## Reasonable param_df changes, should +/- inf bounds be changed at instantiation of param_df to be actual numbers and not infs. maybe min/max float?\n", + "\n", + "# Nuisance Params\n", + "# Get all parameter names containing 'nuisance_expt'\n", + "fudge_params = [col for col in f.param_df.index if 'nuisance_expt' in col]\n", + "\n", + "# Link all fudge parameters (except 0) to the first one, set first one = 1.1\n", + "for param in fudge_params:\n", + " f.param_df.loc[param, 'guess'] = 1.1\n", + " f.param_df.loc[param, 'fixed'] = True\n", + " f.param_df.loc[param, 'lower_bound'] = -2\n", + " f.param_df.loc[param, 'upper_bound'] = 2\n", + "\n", + "# ## K bounds\n", + "\n", + "eq_constants = [col for col in f.param_df.index if 'K' in col]\n", + "for param in eq_constants:\n", + " f.param_df.loc[param, 'upper_bound'] = 30\n", + " f.param_df.loc[param, 'lower_bound'] = -30\n", + "\n", + "# Heats\n", + "heat_constants = [col for col in f.param_df.index if 'dH_' in col]\n", + "for param in heat_constants:\n", + " f.param_df.loc[param, 'upper_bound'] = 30000\n", + " f.param_df.loc[param, 'lower_bound'] = -30000" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "19af95f1-ed3c-4fde-acd9-d17d1e45d195", + "metadata": {}, + "outputs": [], + "source": [ + "f.param_df.loc[\"KM\",\"guess\"] = -2\n", + "f.param_df.loc[\"KM\",\"upper_bound\"] = 10\n", + "f.param_df.loc[\"KM\",\"lower_bound\"] = -10\n", + "f.param_df.loc[\"dH_M\",\"guess\"] = 0\n", + "f.param_df.loc[\"dH_M\",\"fixed\"] = True" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "059ebc3b-c8f3-4688-a5cf-4b8fc3cd5ef0", + "metadata": {}, + "outputs": [], + "source": [ + "### Parameters from CaEDTA fitting\n", + "\n", + "# EDTA K/dH\n", + "f.param_df.loc[\"KE\",\"guess\"] = 16.18\n", + "f.param_df.loc[\"KE\",\"upper_bound\"] = 16.20\n", + "f.param_df.loc[\"KE\",\"lower_bound\"] = 16.16\n", + "f.param_df.loc[\"KE\",\"fixed\"] = True\n", + "\n", + "f.param_df.loc[\"dH_E\",\"guess\"] = -10902\n", + "f.param_df.loc[\"dH_E\",\"upper_bound\"] = -10800\n", + "f.param_df.loc[\"dH_E\",\"lower_bound\"] = -11000\n", + "f.param_df.loc[\"dH_E\",\"fixed\"] = True\n", + "\n", + "# # ### Nuisance Param Guesses\n", + "f.param_df.loc[\"nuisance_dil_CT\",\"guess\"] = -400\n", + "f.param_df.loc[\"nuisance_dil_CT\",\"upper_bound\"] = -380\n", + "f.param_df.loc[\"nuisance_dil_CT\",\"lower_bound\"] = -420\n", + "f.param_df.loc[\"nuisance_dil_CT\",\"fixed\"] = True\n", + "\n", + "f.param_df.loc[\"nuisance_dil_ET\",\"guess\"] = 30\n", + "f.param_df.loc[\"nuisance_dil_ET\",\"upper_bound\"] = 40\n", + "f.param_df.loc[\"nuisance_dil_ET\",\"lower_bound\"] = 20\n", + "f.param_df.loc[\"nuisance_dil_ET\",\"fixed\"] = True\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4ac7eaa7-d428-497a-8bb9-1e6d36580023", + "metadata": { + "editable": true, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "## Parameter Specs\n", + "f.param_df.loc[\"KI\",\"guess\"] = -4.6\n", + "f.param_df.loc[\"KI\",\"upper_bound\"] = -2\n", + "f.param_df.loc[\"KI\",\"lower_bound\"] = -10\n", + "f.param_df.loc[\"KI\",\"fixed\"] = False\n", + "\n", + "f.param_df.loc[\"K1\",\"guess\"] = 10\n", + "f.param_df.loc[\"K1\",\"upper_bound\"] = 20\n", + "f.param_df.loc[\"K1\",\"lower_bound\"] = 7\n", + "f.param_df.loc[\"K1\",\"fixed\"] = False\n", + "\n", + "f.param_df.loc[\"K2\",\"guess\"] = 7\n", + "f.param_df.loc[\"K2\",\"upper_bound\"] = 20\n", + "f.param_df.loc[\"K2\",\"lower_bound\"] = 7\n", + "f.param_df.loc[\"K2\",\"fixed\"] = False\n", + "\n", + "f.param_df.loc[\"K3\",\"guess\"] = 7\n", + "f.param_df.loc[\"K3\",\"upper_bound\"] = 11\n", + "f.param_df.loc[\"K3\",\"lower_bound\"] = 2\n", + "f.param_df.loc[\"K3\",\"fixed\"] = False\n", + "\n", + "f.param_df.loc[\"K4\",\"guess\"] = 7\n", + "f.param_df.loc[\"K4\",\"upper_bound\"] = 11\n", + "f.param_df.loc[\"K4\",\"lower_bound\"] = 2\n", + "f.param_df.loc[\"K4\", \"fixed\"] = False\n", + "\n", + "\n", + "# # ### Enthalpy Guesses\n", + "\n", + "f.param_df.loc[\"dH_I\",\"guess\"] = 0\n", + "f.param_df.loc[\"dH_I\",\"fixed\"] = True\n", + "\n", + "f.param_df.loc[\"dH_E\",\"guess\"] = -10902\n", + "f.param_df.loc[\"dH_E\",\"upper_bound\"] = -10800\n", + "f.param_df.loc[\"dH_E\",\"lower_bound\"] = -11000\n", + "f.param_df.loc[\"dH_E\",\"fixed\"] = True\n", + "\n", + "f.param_df.loc[\"dH_1\",\"guess\"] = 100\n", + "f.param_df.loc[\"dH_1\",\"upper_bound\"] = 10000\n", + "f.param_df.loc[\"dH_1\",\"lower_bound\"] = 0\n", + "\n", + "f.param_df.loc[\"dH_2\",\"guess\"] = 100\n", + "f.param_df.loc[\"dH_2\",\"upper_bound\"] = 10000\n", + "f.param_df.loc[\"dH_2\",\"lower_bound\"] = 0\n", + "\n", + "f.param_df.loc[\"dH_3\",\"guess\"] = 100\n", + "f.param_df.loc[\"dH_3\",\"upper_bound\"] = 10000\n", + "f.param_df.loc[\"dH_3\",\"lower_bound\"] = 0\n", + "\n", + "f.param_df.loc[\"dH_4\",\"guess\"] = 100\n", + "f.param_df.loc[\"dH_4\",\"upper_bound\"] = 10000\n", + "f.param_df.loc[\"dH_4\",\"lower_bound\"] = 0\n", + "\n", + "\n", + "# f.param_df.loc[\"\",\"parent\"] = ''" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "64e5faa0-8977-402d-9d4a-0bb635afddec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE16.180000True16.16000016.200000NaNNaN
KMKM-2.000000False-10.00000010.000000NaNNaN
KIKI-4.600000False-10.000000-2.000000NaNNaN
K1K110.000000False7.00000020.000000NaNNaN
K2K27.000000False7.00000020.000000NaNNaN
K3K37.000000False2.00000011.000000NaNNaN
K4K47.000000False2.00000011.000000NaNNaN
dH_EdH_E-10902.000000True-11000.000000-10800.000000NaNNaN
dH_MdH_M0.000000True-30000.00000030000.000000NaNNaN
dH_IdH_I0.000000True-30000.00000030000.000000NaNNaN
dH_1dH_1100.000000False0.00000010000.000000NaNNaN
dH_2dH_2100.000000False0.00000010000.000000NaNNaN
dH_3dH_3100.000000False0.00000010000.000000NaNNaN
dH_4dH_4100.000000False0.00000010000.000000NaNNaN
nuisance_dil_CTnuisance_dil_CT-400.000000True-420.000000-380.000000NaNNaN
nuisance_dil_ETnuisance_dil_ET30.000000True20.00000040.000000NaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_10_ET_fudgenuisance_expt_10_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_11_ET_fudgenuisance_expt_11_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_12_ET_fudgenuisance_expt_12_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_13_ET_fudgenuisance_expt_13_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_14_ET_fudgenuisance_expt_14_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_15_ET_fudgenuisance_expt_15_ET_fudge1.100000True-2.0000002.000000NaNNaN
nuisance_expt_16_ET_fudgenuisance_expt_16_ET_fudge1.100000True-2.0000002.000000NaNNaN
\n", + "
" + ], + "text/plain": [ + " name guess fixed \\\n", + "name \n", + "KE KE 16.180000 True \n", + "KM KM -2.000000 False \n", + "KI KI -4.600000 False \n", + "K1 K1 10.000000 False \n", + "K2 K2 7.000000 False \n", + "K3 K3 7.000000 False \n", + "K4 K4 7.000000 False \n", + "dH_E dH_E -10902.000000 True \n", + "dH_M dH_M 0.000000 True \n", + "dH_I dH_I 0.000000 True \n", + "dH_1 dH_1 100.000000 False \n", + "dH_2 dH_2 100.000000 False \n", + "dH_3 dH_3 100.000000 False \n", + "dH_4 dH_4 100.000000 False \n", + "nuisance_dil_CT nuisance_dil_CT -400.000000 True \n", + "nuisance_dil_ET nuisance_dil_ET 30.000000 True \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge 1.100000 True \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge 1.100000 True \n", + "nuisance_expt_2_ET_fudge nuisance_expt_2_ET_fudge 1.100000 True \n", + "nuisance_expt_3_ET_fudge nuisance_expt_3_ET_fudge 1.100000 True \n", + "nuisance_expt_4_ET_fudge nuisance_expt_4_ET_fudge 1.100000 True \n", + "nuisance_expt_5_ET_fudge nuisance_expt_5_ET_fudge 1.100000 True \n", + "nuisance_expt_6_ET_fudge nuisance_expt_6_ET_fudge 1.100000 True \n", + "nuisance_expt_7_ET_fudge nuisance_expt_7_ET_fudge 1.100000 True \n", + "nuisance_expt_8_ET_fudge nuisance_expt_8_ET_fudge 1.100000 True \n", + "nuisance_expt_9_ET_fudge nuisance_expt_9_ET_fudge 1.100000 True \n", + "nuisance_expt_10_ET_fudge nuisance_expt_10_ET_fudge 1.100000 True \n", + "nuisance_expt_11_ET_fudge nuisance_expt_11_ET_fudge 1.100000 True \n", + "nuisance_expt_12_ET_fudge nuisance_expt_12_ET_fudge 1.100000 True \n", + "nuisance_expt_13_ET_fudge nuisance_expt_13_ET_fudge 1.100000 True \n", + "nuisance_expt_14_ET_fudge nuisance_expt_14_ET_fudge 1.100000 True \n", + "nuisance_expt_15_ET_fudge nuisance_expt_15_ET_fudge 1.100000 True \n", + "nuisance_expt_16_ET_fudge nuisance_expt_16_ET_fudge 1.100000 True \n", + "\n", + " lower_bound upper_bound prior_mean prior_std \n", + "name \n", + "KE 16.160000 16.200000 NaN NaN \n", + "KM -10.000000 10.000000 NaN NaN \n", + "KI -10.000000 -2.000000 NaN NaN \n", + "K1 7.000000 20.000000 NaN NaN \n", + "K2 7.000000 20.000000 NaN NaN \n", + "K3 2.000000 11.000000 NaN NaN \n", + "K4 2.000000 11.000000 NaN NaN \n", + "dH_E -11000.000000 -10800.000000 NaN NaN \n", + "dH_M -30000.000000 30000.000000 NaN NaN \n", + "dH_I -30000.000000 30000.000000 NaN NaN \n", + "dH_1 0.000000 10000.000000 NaN NaN \n", + "dH_2 0.000000 10000.000000 NaN NaN \n", + "dH_3 0.000000 10000.000000 NaN NaN \n", + "dH_4 0.000000 10000.000000 NaN NaN \n", + "nuisance_dil_CT -420.000000 -380.000000 NaN NaN \n", + "nuisance_dil_ET 20.000000 40.000000 NaN NaN \n", + "nuisance_expt_0_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_1_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_2_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_3_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_4_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_5_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_6_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_7_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_8_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_9_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_10_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_11_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_12_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_13_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_14_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_15_ET_fudge -2.000000 2.000000 NaN NaN \n", + "nuisance_expt_16_ET_fudge -2.000000 2.000000 NaN NaN " + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.param_df" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "c5a86763-1f1d-434f-ab80-a3f2437aefac", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Residuals are not finite in the initial point.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[30], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# Run fit\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43my_obs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43my_obs_normalized\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43my_std\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#max_convergence_cycles=1,\u001b[39;49;00m\n\u001b[0;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#use_ml_guess=False,\u001b[39;49;00m\n\u001b[0;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#num_steps=800,\u001b[39;49;00m\n\u001b[0;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#num_walkers=200, # number of markov chains to use in the analysis, default=100 \u001b[39;49;00m\n\u001b[0;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtrf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Algorithm to use for optimization\u001b[39;49;00m\n\u001b[0;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mjac\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m3-point\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Method for computing the Jacobian matrix\u001b[39;49;00m\n\u001b[0;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mftol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1e-10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Tolerance for termination by the change of the cost function\u001b[39;49;00m\n\u001b[0;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mxtol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1e-5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Tolerance for termination by the change of the independent variables\u001b[39;49;00m\n\u001b[0;32m 14\u001b[0m \u001b[43m \u001b[49m\u001b[43mgtol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1e-8\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Tolerance for termination by the norm of the gradient\u001b[39;49;00m\n\u001b[0;32m 15\u001b[0m \u001b[43m \u001b[49m\u001b[43mx_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mjac\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Scaling of the variables\u001b[39;49;00m\n\u001b[0;32m 16\u001b[0m \u001b[43m \u001b[49m\u001b[43mloss\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlinear\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Loss function for dealing with outliers\u001b[39;49;00m\n\u001b[0;32m 17\u001b[0m \u001b[43m \u001b[49m\u001b[43mf_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Soft margin between inlier and outlier residuals\u001b[39;49;00m\n\u001b[0;32m 18\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_nfev\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Maximum number of function evaluations\u001b[39;49;00m\n\u001b[0;32m 19\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Level of algorithm's verbosity\u001b[39;49;00m\n\u001b[0;32m 20\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\ml.py:52\u001b[0m, in \u001b[0;36mMLFitter.fit\u001b[1;34m(self, y_obs, y_std, num_samples, **least_squares_kwargs)\u001b[0m\n\u001b[0;32m 28\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 29\u001b[0m \u001b[38;5;124;03mFit the model parameters to the data by maximum likelihood.\u001b[39;00m\n\u001b[0;32m 30\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 45\u001b[0m \u001b[38;5;124;03m scipy.optimize.least_squares\u001b[39;00m\n\u001b[0;32m 46\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 48\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_samples \u001b[38;5;241m=\u001b[39m check_int(value\u001b[38;5;241m=\u001b[39mnum_samples,\n\u001b[0;32m 49\u001b[0m variable_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnum_samples\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 50\u001b[0m minimum_allowed\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m---> 52\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_obs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_obs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 53\u001b[0m \u001b[43m \u001b[49m\u001b[43my_std\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_std\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mleast_squares_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\base.py:173\u001b[0m, in \u001b[0;36mFitter.fit\u001b[1;34m(self, y_obs, y_std, **kwargs)\u001b[0m\n\u001b[0;32m 170\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model\u001b[38;5;241m.\u001b[39mfinalize_params()\n\u001b[0;32m 172\u001b[0m \u001b[38;5;66;03m# Run the fit\u001b[39;00m\n\u001b[1;32m--> 173\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 175\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_has_been_run \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\ml.py:73\u001b[0m, in \u001b[0;36mMLFitter._fit\u001b[1;34m(self, **kwargs)\u001b[0m\n\u001b[0;32m 71\u001b[0m \u001b[38;5;66;03m# Do the actual fit\u001b[39;00m\n\u001b[0;32m 72\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfn\u001b[39m(\u001b[38;5;241m*\u001b[39margs): \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m-\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_weighted_residuals(\u001b[38;5;241m*\u001b[39margs)\n\u001b[1;32m---> 73\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_result \u001b[38;5;241m=\u001b[39m \u001b[43moptimize\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mleast_squares\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 74\u001b[0m \u001b[43m \u001b[49m\u001b[43mx0\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mguesses\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 75\u001b[0m \u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbounds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 76\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 78\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_success \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_result\u001b[38;5;241m.\u001b[39msuccess\n\u001b[0;32m 80\u001b[0m \u001b[38;5;66;03m# Delete samples if they were present from a previous fit\u001b[39;00m\n", + "File \u001b[1;32m~\\anaconda3\\envs\\fitdata\\Lib\\site-packages\\scipy\\optimize\\_lsq\\least_squares.py:839\u001b[0m, in \u001b[0;36mleast_squares\u001b[1;34m(fun, x0, jac, bounds, method, ftol, xtol, gtol, x_scale, loss, f_scale, diff_step, tr_solver, tr_options, jac_sparsity, max_nfev, verbose, args, kwargs)\u001b[0m\n\u001b[0;32m 835\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`fun` must return at most 1-d array_like. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 836\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mf0.shape: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mf0\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 838\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39mall(np\u001b[38;5;241m.\u001b[39misfinite(f0)):\n\u001b[1;32m--> 839\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResiduals are not finite in the initial point.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 841\u001b[0m n \u001b[38;5;241m=\u001b[39m x0\u001b[38;5;241m.\u001b[39msize\n\u001b[0;32m 842\u001b[0m m \u001b[38;5;241m=\u001b[39m f0\u001b[38;5;241m.\u001b[39msize\n", + "\u001b[1;31mValueError\u001b[0m: Residuals are not finite in the initial point." + ] + } + ], + "source": [ + "# Run fit\n", + "\n", + "f.fit(\n", + " y_obs=gm.y_obs_normalized,\n", + " y_std=0.1,\n", + " #max_convergence_cycles=1,\n", + " #use_ml_guess=False,\n", + " #num_steps=800,\n", + " #num_walkers=200, # number of markov chains to use in the analysis, default=100 \n", + " method='trf', # Algorithm to use for optimization\n", + " jac='3-point', # Method for computing the Jacobian matrix\n", + " ftol=1e-10, # Tolerance for termination by the change of the cost function\n", + " xtol=1e-5, # Tolerance for termination by the change of the independent variables\n", + " gtol=1e-8, # Tolerance for termination by the norm of the gradient\n", + " x_scale='jac', # Scaling of the variables\n", + " loss='linear', # Loss function for dealing with outliers\n", + " f_scale=0.1, # Soft margin between inlier and outlier residuals\n", + " max_nfev=None, # Maximum number of function evaluations\n", + " verbose=2 # Level of algorithm's verbosity\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3a10f7f1-4d41-4f27-ac56-46c6afd61660", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameestimatestdlow_95high_95guessfixedlower_boundupper_boundprior_meanprior_std
name
KEKENaNNaNNaNNaN0.000000False-infinfNaNNaN
KMKMNaNNaNNaNNaN0.000000False-infinfNaNNaN
KIKINaNNaNNaNNaN0.000000False-infinfNaNNaN
K1K1NaNNaNNaNNaN0.000000False-infinfNaNNaN
K2K2NaNNaNNaNNaN0.000000False-infinfNaNNaN
K3K3NaNNaNNaNNaN0.000000False-infinfNaNNaN
K4K4NaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_EdH_ENaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_MdH_MNaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_IdH_INaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_1dH_1NaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_2dH_2NaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_3dH_3NaNNaNNaNNaN0.000000False-infinfNaNNaN
dH_4dH_4NaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_dil_CTnuisance_dil_CTNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ETNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_10_ET_fudgenuisance_expt_10_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_11_ET_fudgenuisance_expt_11_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_12_ET_fudgenuisance_expt_12_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_13_ET_fudgenuisance_expt_13_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_14_ET_fudgenuisance_expt_14_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_15_ET_fudgenuisance_expt_15_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
nuisance_expt_16_ET_fudgenuisance_expt_16_ET_fudgeNaNNaNNaNNaN0.000000False-infinfNaNNaN
\n", + "
" + ], + "text/plain": [ + " name estimate std low_95 \\\n", + "name \n", + "KE KE NaN NaN NaN \n", + "KM KM NaN NaN NaN \n", + "KI KI NaN NaN NaN \n", + "K1 K1 NaN NaN NaN \n", + "K2 K2 NaN NaN NaN \n", + "K3 K3 NaN NaN NaN \n", + "K4 K4 NaN NaN NaN \n", + "dH_E dH_E NaN NaN NaN \n", + "dH_M dH_M NaN NaN NaN \n", + "dH_I dH_I NaN NaN NaN \n", + "dH_1 dH_1 NaN NaN NaN \n", + "dH_2 dH_2 NaN NaN NaN \n", + "dH_3 dH_3 NaN NaN NaN \n", + "dH_4 dH_4 NaN NaN NaN \n", + "nuisance_dil_CT nuisance_dil_CT NaN NaN NaN \n", + "nuisance_dil_ET nuisance_dil_ET NaN NaN NaN \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge NaN NaN NaN \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge NaN NaN NaN \n", + "nuisance_expt_2_ET_fudge nuisance_expt_2_ET_fudge NaN NaN NaN \n", + "nuisance_expt_3_ET_fudge nuisance_expt_3_ET_fudge NaN NaN NaN \n", + "nuisance_expt_4_ET_fudge nuisance_expt_4_ET_fudge NaN NaN NaN \n", + "nuisance_expt_5_ET_fudge nuisance_expt_5_ET_fudge NaN NaN NaN \n", + "nuisance_expt_6_ET_fudge nuisance_expt_6_ET_fudge NaN NaN NaN \n", + "nuisance_expt_7_ET_fudge nuisance_expt_7_ET_fudge NaN NaN NaN \n", + "nuisance_expt_8_ET_fudge nuisance_expt_8_ET_fudge NaN NaN NaN \n", + "nuisance_expt_9_ET_fudge nuisance_expt_9_ET_fudge NaN NaN NaN \n", + "nuisance_expt_10_ET_fudge nuisance_expt_10_ET_fudge NaN NaN NaN \n", + "nuisance_expt_11_ET_fudge nuisance_expt_11_ET_fudge NaN NaN NaN \n", + "nuisance_expt_12_ET_fudge nuisance_expt_12_ET_fudge NaN NaN NaN \n", + "nuisance_expt_13_ET_fudge nuisance_expt_13_ET_fudge NaN NaN NaN \n", + "nuisance_expt_14_ET_fudge nuisance_expt_14_ET_fudge NaN NaN NaN \n", + "nuisance_expt_15_ET_fudge nuisance_expt_15_ET_fudge NaN NaN NaN \n", + "nuisance_expt_16_ET_fudge nuisance_expt_16_ET_fudge NaN NaN NaN \n", + "\n", + " high_95 guess fixed lower_bound upper_bound \\\n", + "name \n", + "KE NaN 0.000000 False -inf inf \n", + "KM NaN 0.000000 False -inf inf \n", + "KI NaN 0.000000 False -inf inf \n", + "K1 NaN 0.000000 False -inf inf \n", + "K2 NaN 0.000000 False -inf inf \n", + "K3 NaN 0.000000 False -inf inf \n", + "K4 NaN 0.000000 False -inf inf \n", + "dH_E NaN 0.000000 False -inf inf \n", + "dH_M NaN 0.000000 False -inf inf \n", + "dH_I NaN 0.000000 False -inf inf \n", + "dH_1 NaN 0.000000 False -inf inf \n", + "dH_2 NaN 0.000000 False -inf inf \n", + "dH_3 NaN 0.000000 False -inf inf \n", + "dH_4 NaN 0.000000 False -inf inf \n", + "nuisance_dil_CT NaN 0.000000 False -inf inf \n", + "nuisance_dil_ET NaN 0.000000 False -inf inf \n", + "nuisance_expt_0_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_1_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_2_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_3_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_4_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_5_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_6_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_7_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_8_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_9_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_10_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_11_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_12_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_13_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_14_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_15_ET_fudge NaN 0.000000 False -inf inf \n", + "nuisance_expt_16_ET_fudge NaN 0.000000 False -inf inf \n", + "\n", + " prior_mean prior_std \n", + "name \n", + "KE NaN NaN \n", + "KM NaN NaN \n", + "KI NaN NaN \n", + "K1 NaN NaN \n", + "K2 NaN NaN \n", + "K3 NaN NaN \n", + "K4 NaN NaN \n", + "dH_E NaN NaN \n", + "dH_M NaN NaN \n", + "dH_I NaN NaN \n", + "dH_1 NaN NaN \n", + "dH_2 NaN NaN \n", + "dH_3 NaN NaN \n", + "dH_4 NaN NaN \n", + "nuisance_dil_CT NaN NaN \n", + "nuisance_dil_ET NaN NaN \n", + "nuisance_expt_0_ET_fudge NaN NaN \n", + "nuisance_expt_1_ET_fudge NaN NaN \n", + "nuisance_expt_2_ET_fudge NaN NaN \n", + "nuisance_expt_3_ET_fudge NaN NaN \n", + "nuisance_expt_4_ET_fudge NaN NaN \n", + "nuisance_expt_5_ET_fudge NaN NaN \n", + "nuisance_expt_6_ET_fudge NaN NaN \n", + "nuisance_expt_7_ET_fudge NaN NaN \n", + "nuisance_expt_8_ET_fudge NaN NaN \n", + "nuisance_expt_9_ET_fudge NaN NaN \n", + "nuisance_expt_10_ET_fudge NaN NaN \n", + "nuisance_expt_11_ET_fudge NaN NaN \n", + "nuisance_expt_12_ET_fudge NaN NaN \n", + "nuisance_expt_13_ET_fudge NaN NaN \n", + "nuisance_expt_14_ET_fudge NaN NaN \n", + "nuisance_expt_15_ET_fudge NaN NaN \n", + "nuisance_expt_16_ET_fudge NaN NaN " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.float_format', lambda x: '%.6f' % x)\n", + "f.fit_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aea1cd7c-d33e-4145-b0de-554d367ab533", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "# Create figure with reasonable size\n", + "plt.figure(figsize=(12, 8))\n", + "# Plot each column against the index\n", + "for column in concs_df.columns:\n", + " plt.plot(concs_df.index[3472:3531], concs_df[column][3472:3531], label=column)\n", + " \n", + "# Add labels and legend\n", + "plt.xlabel('Step Number')\n", + "plt.ylabel('Concentration')\n", + "plt.title('Species Concentrations')\n", + "plt.legend()\n", + "# Show grid\n", + "plt.grid(True)\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bd7e7f25-2292-4a3d-a51c-5b7a3a0801d6", + "metadata": {}, + "source": [ + "## f.fit_quality" + ] + }, + { + "cell_type": "markdown", + "id": "1987676f-1c6a-44a3-995e-44af42226172", + "metadata": {}, + "source": [ + "#### Plot results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a", + "metadata": { + "editable": true, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "style = {\"s\":50,\n", + " \"facecolor\":\"none\",\n", + " \"edgecolor\":\"black\"}\n", + "err_style = {\"lw\":0,\n", + " \"elinewidth\":1,\n", + " \"capsize\":2}\n", + "\n", + "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n", + "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n", + "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n", + "\n", + "edtaca_length = len(edtaca_list)\n", + "prot_length = len(prot_list)\n", + "blank_length = len(blank_list)\n", + "\n", + "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n", + "\n", + "fig, ax = plt.subplots(1,figsize=(6,6))\n", + "\n", + "out_df = gm.as_df.copy()\n", + "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n", + "\n", + "for i in np.unique(out_df.expt_id):\n", + " \n", + " style[\"edgecolor\"] = color_order[i]\n", + " err_style[\"color\"] = color_order[i]\n", + "\n", + " mask = out_df[\"expt_id\"] == i\n", + " this_df = out_df.loc[mask,:]\n", + "\n", + " \n", + " x_values = np.cumsum(this_df[\"injection\"])\n", + " y_values = np.array(this_df[\"y_obs\"])\n", + " y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n", + " this_y_calc = y_calc[mask]/this_df[\"injection\"]\n", + "\n", + " y_values = y_values/this_df[\"injection\"]\n", + " \n", + " ax.scatter(x_values,y_values,**style)\n", + " ax.errorbar(x=x_values,\n", + " y=y_values,\n", + " #yerr=y_err,\n", + " **err_style)\n", + "\n", + " ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n", + "\n", + "ax.set_ylim((-100,10))\n", + "\n", + "plt.xlabel(\"injection\")\n", + "plt.ylabel(\"heat\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4d89a05-fb93-4255-bf26-e39db481e303", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "style = {\"s\":50,\n", + " \"facecolor\":\"none\",\n", + " \"edgecolor\":\"black\"}\n", + "err_style = {\"lw\":0,\n", + " \"elinewidth\":1,\n", + " \"capsize\":2}\n", + "\n", + "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n", + "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n", + "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n", + "\n", + "fig, ax = plt.subplots(1,figsize=(6,6))\n", + "\n", + "out_df = gm.as_df.copy()\n", + "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n", + "\n", + "for i in np.unique(out_df.expt_id):\n", + " \n", + " style[\"edgecolor\"] = \"blue\"\n", + " err_style[\"color\"] = \"red\"\n", + "\n", + " mask = out_df[\"expt_id\"] == i\n", + " this_df = out_df.loc[mask,:]\n", + "\n", + " \n", + " x_values = np.cumsum(this_df[\"injection\"])\n", + " y_values = np.array(this_df[\"y_obs\"])\n", + " y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n", + " this_y_calc = y_calc[mask]/this_df[\"injection\"]\n", + "\n", + " y_values = y_values/this_df[\"injection\"]\n", + " \n", + " ax.scatter(x_values,y_values,**style)\n", + " ax.errorbar(x=x_values,\n", + " y=y_values,\n", + " #yerr=y_err,\n", + " **err_style)\n", + "\n", + " ax.plot(x_values,this_y_calc,'-',color=\"red\")\n", + "\n", + "ax.set_ylim((-100,10))\n", + "\n", + "plt.xlabel(\"injection\")\n", + "plt.ylabel(\"heat\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7875819c-4e89-4de4-a8c0-bdafe99c819a", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "# Print column names for one of each type of experiment\n", + "print(\"Blank experiment columns:\")\n", + "print(blank_list[0].expt_concs.columns)\n", + "print(\"\\nEDTA-Ca experiment columns:\")\n", + "print(edtaca_list[0].expt_concs.columns)\n", + "print(\"\\nProtein experiment columns:\")\n", + "print(prot_list[0].expt_concs.columns)\n", + "\n", + "# Check data structure\n", + "print(\"\\nSample of concentration data:\")\n", + "print(prot_list[0].expt_concs.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "327fc64a-a64e-4c18-9727-b2b2a90c5cc3", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot settings\n", + "style = {\"s\": 50, \"facecolor\": \"none\"}\n", + "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n", + "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n", + "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n", + "\n", + "# Get fitted parameters and calculate theoretical heats\n", + "params = np.array(f.fit_df[\"estimate\"])\n", + "y_calc = gm.model(params)\n", + "\n", + "fig, ax = plt.subplots(1, figsize=(8,6))\n", + "\n", + "# Get overall y range from experimental data to set limits\n", + "y_min = gm.as_df[\"y_obs\"].min()\n", + "y_max = gm.as_df[\"y_obs\"].max()\n", + "y_range = y_max - y_min\n", + "y_limits = [y_min - 15*y_range, y_max + 15*y_range]\n", + "\n", + "# Plot each experiment\n", + "for i in np.unique(gm.as_df.expt_id):\n", + " style[\"edgecolor\"] = color_order[i]\n", + " \n", + " # Get data for this experiment using gm.as_df\n", + " mask = gm.as_df.expt_id == i\n", + " this_df = gm.as_df.loc[mask,:]\n", + " \n", + " # Get theoretical heats for this experiment\n", + " heats = y_calc[mask]\n", + " # Calculate injection-to-injection differences\n", + " heat_diffs = np.diff(heats, prepend=heats[0])\n", + " \n", + " # Get experimental points\n", + " x_values = np.cumsum(this_df[\"injection\"])\n", + " y_values = this_df[\"y_obs\"]\n", + " \n", + " # Plot experimental points\n", + " ax.scatter(x_values, y_values, \n", + " **style,\n", + " label=f'Expt {i} (data)')\n", + " \n", + " # Plot theoretical curve using differences\n", + " ax.plot(x_values, heat_diffs, '-',\n", + " color=color_order[i],\n", + " label=f'Expt {i} (fit)')\n", + "\n", + "ax.set_xlabel('Cumulative Injection')\n", + "ax.set_ylabel('Heat per injection (μcal)')\n", + "ax.set_ylim(y_limits)\n", + "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d72d8bfd-d925-445e-967d-4f6603621a2d", + "metadata": {}, + "outputs": [], + "source": [ + "fig = dataprob.plot_corner(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "fig = dataprob.plot_summary(f)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81dc68e5-756e-4b53-8b09-704f935525e7", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "# No error consideration\n", + "style = {\n", + " \"s\": 50,\n", + " \"facecolor\": \"none\",\n", + " \"edgecolor\": \"black\"\n", + "}\n", + "\n", + "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n", + "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n", + "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n", + "\n", + "edtaca_length = len(edtaca_list)\n", + "prot_length = len(prot_list)\n", + "blank_length = len(blank_list)\n", + "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n", + "\n", + "fig, ax = plt.subplots(1, figsize=(6,6))\n", + "out_df = gm.as_df.copy()\n", + "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n", + "\n", + "for i in np.unique(out_df.expt_id):\n", + " style[\"edgecolor\"] = color_order[i]\n", + " mask = out_df[\"expt_id\"] == i\n", + " this_df = out_df.loc[mask,:]\n", + " \n", + " x_values = np.cumsum(this_df[\"injection\"])\n", + " y_values = np.array(this_df[\"y_obs\"])\n", + " this_y_calc = y_calc[mask]/this_df[\"injection\"]\n", + " y_values = y_values/this_df[\"injection\"]\n", + " \n", + " ax.scatter(x_values, y_values, **style)\n", + " ax.plot(x_values, this_y_calc, '-', color=color_order[i])\n", + " \n", + "plt.xlabel(\"injection\")\n", + "plt.ylabel(\"heat\")\n", + "f.fit_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc9b3969-cf7e-46f4-a467-1c128f45a228", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/genericmodelimplementation_6state.ipynb b/notebooks/genericmodelimplementation_6state.ipynb new file mode 100644 index 0000000..4a31552 --- /dev/null +++ b/notebooks/genericmodelimplementation_6state.ipynb @@ -0,0 +1,1805 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b11cea11-6bb7-4286-9550-6a47f3c017ad", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import dataprob\n", + "import copy\n", + "import linkage" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "75839bf7-0265-4c1b-9bdb-770c1d2fb2f1", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "### Load Experimental Data\n", + "cell_vol = 201.3\n", + "\n", + "## EDTA --> Protein + Ca\n", + "prot1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4HIGHRES.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "prot2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4SUPERDUPERRES.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "prot3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240823\\3mMEDTAto50uMhA4.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot3.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "prot4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA4.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot4.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "prot5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA42.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot5.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "prot6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA43.csv\",\n", + " cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "prot6.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "## Ca -> EDTA + Protein\n", + "\n", + "reprot1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA50uMhA4.csv\",\n", + " cell_contents={\"ET\":50e-6, \"AT\":25e-6},\n", + " syringe_contents={\"CT\":500e-6},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "reprot1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "reprot2 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCato50uMEDTA50uMhA4.csv\",\n", + " cell_contents={\"ET\":50e-6, \"AT\":25e-6},\n", + " syringe_contents={\"CT\":1e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "reprot2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "## EDTA --> Buffer\n", + "\n", + "blank1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa2.csv\",\n", + " cell_contents={\"CT\":0},\n", + " syringe_contents={\"ET\":4e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "blank1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "blank2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa3.csv\",\n", + " cell_contents={\"CT\":0},\n", + " syringe_contents={\"ET\":4e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "blank2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "## Ca --> Buffer\n", + "\n", + "blank3 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer.csv\",\n", + " cell_contents={},\n", + " syringe_contents={\"CT\":1e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"CT\")\n", + "blank3.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "blank4 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer2.csv\",\n", + " cell_contents={},\n", + " syringe_contents={\"CT\":1e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"CT\")\n", + "blank4.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "## Ca --> EDTA\n", + "\n", + "caedta1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA.csv\",\n", + " cell_contents={\"ET\":50e-6},\n", + " syringe_contents={\"CT\":500e-6},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "caedta1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "## EDTA --> Ca\n", + "\n", + "edtaca1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3mMEDTAto500uMCa.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca1.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "edtaca2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240915\\3p5mMEDTAto500uMCaCl2lowres.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca2.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "\n", + "edtaca3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto500uMCaLOWRES.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3.5e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca3.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "edtaca4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca4.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "edtaca5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_2.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca5.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "edtaca6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_3.csv\",\n", + " cell_contents={\"CT\":500e-6},\n", + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=cell_vol,\n", + " conc_to_float=\"ET\")\n", + "edtaca6.define_itc_observable(obs_column=\"heat\",\n", + " obs_std=\"heat_stdev\")\n", + "\n", + "## CD Experiments\n", + "\n", + "# cd1 = linkage.experiment.Experiment(r\"\",\n", + "# cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n", + "# syringe_contents={\"ET\":2e-3},\n", + "# cell_volume=cell_vol,\n", + "# conc_to_float=\"ET\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "973ecc70-baf0-4fc2-a25a-047d67b0da51", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Analytical Jacobian was successfully generated for the binding model.\n" + ] + } + ], + "source": [ + "#### Create model instance\n", + "#Full Lists\n", + "blank_list = [blank1, blank2, blank3, blank4]\n", + "edtaca_list = [caedta1, edtaca1, edtaca2, edtaca3, edtaca4, edtaca5, edtaca6]\n", + "prot_list = [prot1, prot2, prot3, prot4, prot5, prot6, reprot1, reprot2]\n", + "\n", + "#Combine experiment types into one list\n", + "expt_list = blank_list + edtaca_list + prot_list\n", + "\n", + "\n", + "# Read the model specification from file\n", + "spec_file_path = r\"C:\\Users\\willi\\linkage\\src\\linkage\\model_specs\\SixStateEDTA.txt\"\n", + "\n", + "# Read spec\n", + "with open(spec_file_path, 'r') as f:\n", + " model_spec = f.read()\n", + "\n", + "# Create GlobalModel with spec\n", + "gm = linkage.GlobalModel(\n", + " model_name=\"GenericBindingModel\",\n", + " model_spec=model_spec,\n", + " expt_list=expt_list\n", + ")\n", + "\n", + "#Setup dataprob\n", + "f = dataprob.setup(gm.model_normalized,\n", + " method=\"pymc\",\n", + " vector_first_arg=True,\n", + " fit_parameters=gm.parameter_names)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "10064dc1-cb03-4ea7-b107-2dba82d6ba2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
K1K10.0False-infinfNaNNaN
K2K20.0False-infinfNaNNaN
K3K30.0False-infinfNaNNaN
K4K40.0False-infinfNaNNaN
KEKE0.0False-infinfNaNNaN
KIKI0.0False-infinfNaNNaN
dH_1dH_10.0False-infinfNaNNaN
dH_2dH_20.0False-infinfNaNNaN
dH_3dH_30.0False-infinfNaNNaN
dH_4dH_40.0False-infinfNaNNaN
dH_EdH_E0.0False-infinfNaNNaN
dH_IdH_I0.0False-infinfNaNNaN
nuisance_dil_CTnuisance_dil_CT0.0False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ET0.0False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_2_CT_fudgenuisance_expt_2_CT_fudge0.0False-infinfNaNNaN
nuisance_expt_3_CT_fudgenuisance_expt_3_CT_fudge0.0False-infinfNaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_10_ET_fudgenuisance_expt_10_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_11_ET_fudgenuisance_expt_11_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_12_ET_fudgenuisance_expt_12_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_13_ET_fudgenuisance_expt_13_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_14_ET_fudgenuisance_expt_14_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_15_ET_fudgenuisance_expt_15_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_16_ET_fudgenuisance_expt_16_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_17_ET_fudgenuisance_expt_17_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_18_ET_fudgenuisance_expt_18_ET_fudge0.0False-infinfNaNNaN
\n", + "
" + ], + "text/plain": [ + " name guess fixed \\\n", + "name \n", + "K1 K1 0.0 False \n", + "K2 K2 0.0 False \n", + "K3 K3 0.0 False \n", + "K4 K4 0.0 False \n", + "KE KE 0.0 False \n", + "KI KI 0.0 False \n", + "dH_1 dH_1 0.0 False \n", + "dH_2 dH_2 0.0 False \n", + "dH_3 dH_3 0.0 False \n", + "dH_4 dH_4 0.0 False \n", + "dH_E dH_E 0.0 False \n", + "dH_I dH_I 0.0 False \n", + "nuisance_dil_CT nuisance_dil_CT 0.0 False \n", + "nuisance_dil_ET nuisance_dil_ET 0.0 False \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge 0.0 False \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge 0.0 False \n", + "nuisance_expt_2_CT_fudge nuisance_expt_2_CT_fudge 0.0 False \n", + "nuisance_expt_3_CT_fudge nuisance_expt_3_CT_fudge 0.0 False \n", + "nuisance_expt_4_ET_fudge nuisance_expt_4_ET_fudge 0.0 False \n", + "nuisance_expt_5_ET_fudge nuisance_expt_5_ET_fudge 0.0 False \n", + "nuisance_expt_6_ET_fudge nuisance_expt_6_ET_fudge 0.0 False \n", + "nuisance_expt_7_ET_fudge nuisance_expt_7_ET_fudge 0.0 False \n", + "nuisance_expt_8_ET_fudge nuisance_expt_8_ET_fudge 0.0 False \n", + "nuisance_expt_9_ET_fudge nuisance_expt_9_ET_fudge 0.0 False \n", + "nuisance_expt_10_ET_fudge nuisance_expt_10_ET_fudge 0.0 False \n", + "nuisance_expt_11_ET_fudge nuisance_expt_11_ET_fudge 0.0 False \n", + "nuisance_expt_12_ET_fudge nuisance_expt_12_ET_fudge 0.0 False \n", + "nuisance_expt_13_ET_fudge nuisance_expt_13_ET_fudge 0.0 False \n", + "nuisance_expt_14_ET_fudge nuisance_expt_14_ET_fudge 0.0 False \n", + "nuisance_expt_15_ET_fudge nuisance_expt_15_ET_fudge 0.0 False \n", + "nuisance_expt_16_ET_fudge nuisance_expt_16_ET_fudge 0.0 False \n", + "nuisance_expt_17_ET_fudge nuisance_expt_17_ET_fudge 0.0 False \n", + "nuisance_expt_18_ET_fudge nuisance_expt_18_ET_fudge 0.0 False \n", + "\n", + " lower_bound upper_bound prior_mean prior_std \n", + "name \n", + "K1 -inf inf NaN NaN \n", + "K2 -inf inf NaN NaN \n", + "K3 -inf inf NaN NaN \n", + "K4 -inf inf NaN NaN \n", + "KE -inf inf NaN NaN \n", + "KI -inf inf NaN NaN \n", + "dH_1 -inf inf NaN NaN \n", + "dH_2 -inf inf NaN NaN \n", + "dH_3 -inf inf NaN NaN \n", + "dH_4 -inf inf NaN NaN \n", + "dH_E -inf inf NaN NaN \n", + "dH_I -inf inf NaN NaN \n", + "nuisance_dil_CT -inf inf NaN NaN \n", + "nuisance_dil_ET -inf inf NaN NaN \n", + "nuisance_expt_0_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_1_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_2_CT_fudge -inf inf NaN NaN \n", + "nuisance_expt_3_CT_fudge -inf inf NaN NaN \n", + "nuisance_expt_4_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_5_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_6_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_7_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_8_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_9_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_10_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_11_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_12_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_13_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_14_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_15_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_16_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_17_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_18_ET_fudge -inf inf NaN NaN " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.param_df" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a8e9c307-8be7-4bbc-a6ce-d26c5137978a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
K1K18.0False6.010.08.04.00
K2K28.0False6.010.08.04.00
K3K34.0False3.06.04.02.00
K4K44.0False3.06.04.02.00
KEKE16.3True16.216.416.38.15
KIKI-12.0True-12.0-5.0-12.06.00
dH_1dH_1-7000.0False-12000.0-4000.0-7000.03500.00
dH_2dH_2-7000.0False-12000.0-4000.0-7000.03500.00
dH_3dH_3-100.0False-3000.05000.0-100.050.00
dH_4dH_4-100.0False-3000.05000.0-100.050.00
dH_EdH_E-10985.0True-11035.0-10925.0-10985.05492.50
dH_IdH_I0.0True-infinf0.01.00
nuisance_dil_CTnuisance_dil_CT-482.0True-1000.01000.0-482.0241.00
nuisance_dil_ETnuisance_dil_ET-56.0True-1000.01000.0-56.028.00
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.1True0.81.21.10.55
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.1True0.81.21.10.55
nuisance_expt_2_CT_fudgenuisance_expt_2_CT_fudge1.1True0.81.21.10.55
nuisance_expt_3_CT_fudgenuisance_expt_3_CT_fudge1.1True0.81.21.10.55
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.1True0.81.21.10.55
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.1True0.81.21.10.55
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge1.1True0.81.21.10.55
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge1.1True0.81.21.10.55
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge1.1True0.81.21.10.55
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge1.1True0.81.21.10.55
nuisance_expt_10_ET_fudgenuisance_expt_10_ET_fudge1.1True0.81.21.10.55
nuisance_expt_11_ET_fudgenuisance_expt_11_ET_fudge1.1True0.81.21.10.55
nuisance_expt_12_ET_fudgenuisance_expt_12_ET_fudge1.1True0.81.21.10.55
nuisance_expt_13_ET_fudgenuisance_expt_13_ET_fudge1.1True0.81.21.10.55
nuisance_expt_14_ET_fudgenuisance_expt_14_ET_fudge1.1True0.81.21.10.55
nuisance_expt_15_ET_fudgenuisance_expt_15_ET_fudge1.1True0.81.21.10.55
nuisance_expt_16_ET_fudgenuisance_expt_16_ET_fudge1.1True0.81.21.10.55
nuisance_expt_17_ET_fudgenuisance_expt_17_ET_fudge1.1True0.81.21.10.55
nuisance_expt_18_ET_fudgenuisance_expt_18_ET_fudge1.1True0.81.21.10.55
\n", + "
" + ], + "text/plain": [ + " name guess fixed \\\n", + "name \n", + "K1 K1 8.0 False \n", + "K2 K2 8.0 False \n", + "K3 K3 4.0 False \n", + "K4 K4 4.0 False \n", + "KE KE 16.3 True \n", + "KI KI -12.0 True \n", + "dH_1 dH_1 -7000.0 False \n", + "dH_2 dH_2 -7000.0 False \n", + "dH_3 dH_3 -100.0 False \n", + "dH_4 dH_4 -100.0 False \n", + "dH_E dH_E -10985.0 True \n", + "dH_I dH_I 0.0 True \n", + "nuisance_dil_CT nuisance_dil_CT -482.0 True \n", + "nuisance_dil_ET nuisance_dil_ET -56.0 True \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge 1.1 True \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge 1.1 True \n", + "nuisance_expt_2_CT_fudge nuisance_expt_2_CT_fudge 1.1 True \n", + "nuisance_expt_3_CT_fudge nuisance_expt_3_CT_fudge 1.1 True \n", + "nuisance_expt_4_ET_fudge nuisance_expt_4_ET_fudge 1.1 True \n", + "nuisance_expt_5_ET_fudge nuisance_expt_5_ET_fudge 1.1 True \n", + "nuisance_expt_6_ET_fudge nuisance_expt_6_ET_fudge 1.1 True \n", + "nuisance_expt_7_ET_fudge nuisance_expt_7_ET_fudge 1.1 True \n", + "nuisance_expt_8_ET_fudge nuisance_expt_8_ET_fudge 1.1 True \n", + "nuisance_expt_9_ET_fudge nuisance_expt_9_ET_fudge 1.1 True \n", + "nuisance_expt_10_ET_fudge nuisance_expt_10_ET_fudge 1.1 True \n", + "nuisance_expt_11_ET_fudge nuisance_expt_11_ET_fudge 1.1 True \n", + "nuisance_expt_12_ET_fudge nuisance_expt_12_ET_fudge 1.1 True \n", + "nuisance_expt_13_ET_fudge nuisance_expt_13_ET_fudge 1.1 True \n", + "nuisance_expt_14_ET_fudge nuisance_expt_14_ET_fudge 1.1 True \n", + "nuisance_expt_15_ET_fudge nuisance_expt_15_ET_fudge 1.1 True \n", + "nuisance_expt_16_ET_fudge nuisance_expt_16_ET_fudge 1.1 True \n", + "nuisance_expt_17_ET_fudge nuisance_expt_17_ET_fudge 1.1 True \n", + "nuisance_expt_18_ET_fudge nuisance_expt_18_ET_fudge 1.1 True \n", + "\n", + " lower_bound upper_bound prior_mean prior_std \n", + "name \n", + "K1 6.0 10.0 8.0 4.00 \n", + "K2 6.0 10.0 8.0 4.00 \n", + "K3 3.0 6.0 4.0 2.00 \n", + "K4 3.0 6.0 4.0 2.00 \n", + "KE 16.2 16.4 16.3 8.15 \n", + "KI -12.0 -5.0 -12.0 6.00 \n", + "dH_1 -12000.0 -4000.0 -7000.0 3500.00 \n", + "dH_2 -12000.0 -4000.0 -7000.0 3500.00 \n", + "dH_3 -3000.0 5000.0 -100.0 50.00 \n", + "dH_4 -3000.0 5000.0 -100.0 50.00 \n", + "dH_E -11035.0 -10925.0 -10985.0 5492.50 \n", + "dH_I -inf inf 0.0 1.00 \n", + "nuisance_dil_CT -1000.0 1000.0 -482.0 241.00 \n", + "nuisance_dil_ET -1000.0 1000.0 -56.0 28.00 \n", + "nuisance_expt_0_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_1_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_2_CT_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_3_CT_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_4_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_5_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_6_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_7_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_8_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_9_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_10_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_11_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_12_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_13_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_14_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_15_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_16_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_17_ET_fudge 0.8 1.2 1.1 0.55 \n", + "nuisance_expt_18_ET_fudge 0.8 1.2 1.1 0.55 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a dictionary to hold the complete configuration for each parameter.\n", + "# This makes it easy to see all settings for a given parameter in one place.\n", + "param_configs = {\n", + "\n", + " # --- Equilibrium Constants (lnK) ---\n", + " # Since A is favored over I, KI = [I]/[A] << 1, so ln(KI) must be negative.\n", + " \"KI\": {\"guess\": -12.0, \"lower_bound\": -12, \"upper_bound\": -5, \"fixed\": True},\n", + " \n", + " # High-affinity Ca++ binding sites\n", + " \"K1\": {\"guess\": 8, \"lower_bound\": 6, \"upper_bound\": 10, \"fixed\": False},\n", + " \"K2\": {\"guess\": 8, \"lower_bound\": 6, \"upper_bound\": 10, \"fixed\": False},\n", + "\n", + " # Low-affinity Ca++ binding sites\n", + " \"K3\": {\"guess\": 4, \"lower_bound\": 3, \"upper_bound\": 6, \"fixed\": False},\n", + " \"K4\": {\"guess\": 4, \"lower_bound\": 3, \"upper_bound\": 6, \"fixed\": False},\n", + " \n", + " # EDTA binding constant\n", + " \"KE\": {\"guess\": 16.3,\"lower_bound\": 16.2,\"upper_bound\": 16.4,\"fixed\": True},\n", + "\n", + " # --- Enthalpies (in cal/mol) ---\n", + " # Assumed isoenthalpic for the inactive->active transition\n", + " \"dH_I\": {\"guess\": 0, \"fixed\": True}, \n", + " \n", + " # Binding dH should be within a physical range\n", + " \"dH_1\": {\"guess\": -7000, \"lower_bound\": -12000, \"upper_bound\": -4000},\n", + " \"dH_2\": {\"guess\": -7000, \"lower_bound\": -12000, \"upper_bound\": -4000},\n", + " \"dH_3\": {\"guess\": -100, \"lower_bound\": -3000, \"upper_bound\": 5000},\n", + " \"dH_4\": {\"guess\": -100, \"lower_bound\": -3000, \"upper_bound\": 5000},\n", + "\n", + " # EDTA binding enthalpy\n", + " \"dH_E\": {\"guess\": -10985, \"lower_bound\": -11035, \"upper_bound\": -10925, \"fixed\": True},\n", + "\n", + " # --- Nuisance Parameters: Dilution (in ucal/mol) ---\n", + " \"nuisance_dil_CT\": {\"guess\": -482, \"lower_bound\": -1000, \"upper_bound\": 1000, \"fixed\": True},\n", + " \"nuisance_dil_ET\": {\"guess\": -56, \"lower_bound\": -1000, \"upper_bound\": 1000, \"fixed\": True},\n", + "}\n", + "\n", + "# Apply the configurations to the parameter DataFrame\n", + "for param_name, settings in param_configs.items():\n", + " if param_name in f.param_df.index:\n", + " # Use .get() to avoid errors if a key (like 'fixed') is not specified\n", + " for key, value in settings.items():\n", + " f.param_df.loc[param_name, key] = value\n", + " else:\n", + " print(f\"Warning: Parameter '{param_name}' from config not in model.\")\n", + "\n", + "# --- Nuisance Parameters: Experimental Fudge Factors ---\n", + "fudge_params = [name for name in f.param_df.index if 'nuisance_expt' in name]\n", + "for param_name in fudge_params:\n", + " f.param_df.loc[param_name, 'guess'] = 1.1\n", + " f.param_df.loc[param_name, 'fixed'] = True\n", + " f.param_df.loc[param_name, 'lower_bound'] = 0.8\n", + " f.param_df.loc[param_name, 'upper_bound'] = 1.2\n", + "\n", + "# --- Set Prior Means from Guesses ---\n", + "# This uses the initial guess for each parameter as the mean for its prior\n", + "# distribution in the Bayesian model.\n", + "f.param_df['prior_mean'] = f.param_df['guess']\n", + "\n", + "# --- Set Prior Standard Deviations from Means ---\n", + "# Set a fractional value for the standard deviation relative to the mean.\n", + "# 0.5 means the std dev will be 50% of the absolute value of the guess.\n", + "proportion = 0.5\n", + "f.param_df['prior_std'] = proportion * abs(f.param_df['prior_mean'])\n", + "\n", + "# Handle the edge case where the guess is 0. A std dev cannot be 0.\n", + "# We set it to a reasonable default value, like 1.0, for these cases.\n", + "f.param_df.loc[f.param_df['prior_mean'] == 0, 'prior_std'] = 1.0\n", + "\n", + "f.param_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5a86763-1f1d-434f-ab80-a3f2437aefac", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "### ML FITTER FUNCTION CALL (Requires method=\"ml\" in the dataprob fitter setup)\n", + "\n", + "f.fit(\n", + " y_obs=gm.y_obs_normalized,\n", + " y_std=gm.y_std_normalized,\n", + "\n", + " # --- Core Arguments for the Optimizer ---\n", + " method='trf', # Trust Region Reflective is good for bounded problems.\n", + "\n", + " # --- Tolerances ---\n", + " # Loosen ftol/gtol slightly to handle flat regions, keep xtol tight.\n", + " ftol=1e-9, # Termination by change in cost function.\n", + " xtol=1e-6, # Termination by change in parameters.\n", + " gtol=1e-6, # Termination by norm of the gradient.\n", + "\n", + " # --- Scaling and Robustness ---\n", + " x_scale='jac', # Crucial for problems where parameters have very different\n", + " # magnitudes. Let the Jacobian estimate the scales.\n", + " loss='linear', # Standard least-squares. Change to 'soft_l1' if you\n", + " # suspect outliers in your data.\n", + "\n", + " # --- Number of function evaluations ---\n", + " max_nfev=3,\n", + "\n", + " # --- Verbosity ---\n", + " verbose=2 # Keep this at 2 to see the step-by-step progress\n", + " # of the optimization.\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52410c1c-d65d-4e19-b35e-7c47f6f887f9", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "### Emcee FITTER FUNCTION CALL (Requires method=\"emcee\" in the dataprob fitter setup)\n", + "\n", + "\n", + "f.fit(\n", + " y_obs=gm.y_obs_normalized,\n", + " y_std=gm.y_std_normalized,\n", + "\n", + " # Number of walkers to explore parameter space. Should be <2 times the number of fit parameters.\n", + " num_walkers=25,\n", + "\n", + " # Initial number of steps for each walker before checking convergence.\n", + " num_steps=50,\n", + "\n", + " # Use a preliminary ML fit to find a good starting position for the walkers.\n", + " use_ml_guess=False,\n", + "\n", + " # The sampler will automatically try to extend the run this many times to meet convergence criteria.\n", + " max_convergence_cycles=3,\n", + " \n", + " # Fraction of initial steps to discard from each walker for the final analysis.\n", + " burn_in=0.2,\n", + ")\n", + "\n", + "\n", + "### 0.5s per walker per step per experiment??" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7a55525f-edd4-46ce-9237-4b85f648e8fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\willi\\dataprob\\src\\dataprob\\fitters\\bayesian\\pymc.py:125: UserWarning: INFO: Analytical Jacobian found. Using NUTS sampler.\n", + " warnings.warn(\"INFO: Analytical Jacobian found. Using NUTS sampler.\", UserWarning)\n", + "Only 30 samples per chain. Reliable r-hat and ESS diagnostics require longer chains for accurate estimate.\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [K1, K2, K3, K4, dH_1, dH_2, dH_3, dH_4]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ccd93a172eaa47c2b1f01b49c220a889", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Sampling 4 chains for 10 tune and 30 draw iterations (40 + 120 draws total) took 2995 seconds.\n",
+      "There were 102 divergences after tuning. Increase `target_accept` or reparameterize.\n",
+      "The number of samples is too small to check convergence reliably.\n"
+     ]
+    },
+    {
+     "ename": "AttributeError",
+     "evalue": "'InferenceData' object has no attribute 'log_likelihood'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[6], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m### PyMC FITTER FUNCTION CALL (Requires method=\"pymc\" in the dataprob fitter setup)\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m      4\u001b[0m \u001b[43m    \u001b[49m\u001b[43my_obs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43my_obs_normalized\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m      5\u001b[0m \u001b[43m    \u001b[49m\u001b[43my_std\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43my_std_normalized\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m      6\u001b[0m \n\u001b[0;32m      7\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;66;43;03m# Number of independent chains to run. Conceptually similar to walkers.\u001b[39;49;00m\n\u001b[0;32m      8\u001b[0m \u001b[43m    \u001b[49m\u001b[43mchains\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m      9\u001b[0m \n\u001b[0;32m     10\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;66;43;03m# Number of samples to generate and keep from each chain.\u001b[39;49;00m\n\u001b[0;32m     11\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdraws\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m     12\u001b[0m \n\u001b[0;32m     13\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;66;43;03m# Number of \"burn-in\" or \"warmup\" steps to tune the sampler. These are discarded.\u001b[39;49;00m\n\u001b[0;32m     14\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtune\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m     15\u001b[0m \u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\base.py:173\u001b[0m, in \u001b[0;36mFitter.fit\u001b[1;34m(self, y_obs, y_std, **kwargs)\u001b[0m\n\u001b[0;32m    170\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_model\u001b[38;5;241m.\u001b[39mfinalize_params()\n\u001b[0;32m    172\u001b[0m \u001b[38;5;66;03m# Run the fit\u001b[39;00m\n\u001b[1;32m--> 173\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    175\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_has_been_run \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\bayesian\\pymc.py:147\u001b[0m, in \u001b[0;36mPyMCFitter._fit\u001b[1;34m(self, draws, tune, chains, target_accept, **pymc_kwargs)\u001b[0m\n\u001b[0;32m    144\u001b[0m sample_list \u001b[38;5;241m=\u001b[39m [posterior[p]\u001b[38;5;241m.\u001b[39mvalues \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m unfixed_params]\n\u001b[0;32m    145\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_samples \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mstack(sample_list, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m--> 147\u001b[0m log_lik_data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit_result\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_likelihood\u001b[49m\u001b[38;5;241m.\u001b[39mstack(sample\u001b[38;5;241m=\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mchain\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdraw\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m    148\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lnprob \u001b[38;5;241m=\u001b[39m log_lik_data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobs\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mvalues\n\u001b[0;32m    150\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_update_fit_df()\n",
+      "\u001b[1;31mAttributeError\u001b[0m: 'InferenceData' object has no attribute 'log_likelihood'"
+     ]
+    }
+   ],
+   "source": [
+    "### PyMC FITTER FUNCTION CALL (Requires method=\"pymc\" in the dataprob fitter setup)\n",
+    "\n",
+    "f.fit(\n",
+    "    y_obs=gm.y_obs_normalized,\n",
+    "    y_std=gm.y_std_normalized,\n",
+    "\n",
+    "    # Number of independent chains to run. Conceptually similar to walkers.\n",
+    "    chains=4,\n",
+    "\n",
+    "    # Number of samples to generate and keep from each chain.\n",
+    "    draws=30,\n",
+    "\n",
+    "    # Number of \"burn-in\" or \"warmup\" steps to tune the sampler. These are discarded.\n",
+    "    tune=10,\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09232d70-73f5-4703-8cd1-c3d52555f091",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ===================================================================\n",
+    "# DIAGNOSTIC CODE: Test a single evaluation of your model PYMC\n",
+    "# ===================================================================\n",
+    "import numpy as np\n",
+    "import time\n",
+    "import traceback\n",
+    "\n",
+    "# Get the initial guess values that PyMC will start with\n",
+    "# This uses the 'guess' column from your parameter setup.\n",
+    "initial_params = f.param_df[\"guess\"].values.astype(float)\n",
+    "print(\"Testing model with initial parameters (from your guesses):\")\n",
+    "print(initial_params)\n",
+    "\n",
+    "# Now, we will time a single execution of the model function.\n",
+    "# This is the *exact* call that is happening inside the PyMC Op.\n",
+    "print(\"\\n--- Timing a single model evaluation ---\")\n",
+    "start_time = time.time()\n",
+    "try:\n",
+    "    # We are calling the original function wrapped by the model\n",
+    "    result = f._model._model_to_fit(initial_params, **f.non_fit_kwargs)\n",
+    "    end_time = time.time()\n",
+    "\n",
+    "    print(f\"✅ Evaluation finished successfully in {end_time - start_time:.4f} seconds.\")\n",
+    "    print(\"\\n--- Checking output validity ---\")\n",
+    "    print(f\"Output shape: {result.shape}\")\n",
+    "    print(f\"Output contains NaNs: {np.isnan(result).any()}\")\n",
+    "    print(f\"Output is finite: {np.isfinite(result).all()}\")\n",
+    "\n",
+    "except Exception as e:\n",
+    "    print(\"\\n❌ The model evaluation failed with an error:\")\n",
+    "    # This will print the full error traceback from your model function\n",
+    "    traceback.print_exc()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a10f7f1-4d41-4f27-ac56-46c6afd61660",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pd.set_option('display.float_format', lambda x: '%.6f' % x)\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd7e7f25-2292-4a3d-a51c-5b7a3a0801d6",
+   "metadata": {},
+   "source": [
+    "## f.fit_quality"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1987676f-1c6a-44a3-995e-44af42226172",
+   "metadata": {},
+   "source": [
+    "#### Plot results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "style = {\"s\":50,\n",
+    "         \"facecolor\":\"none\",\n",
+    "         \"edgecolor\":\"black\"}\n",
+    "err_style = {\"lw\":0,\n",
+    "             \"elinewidth\":1,\n",
+    "             \"capsize\":2}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "edtaca_length = len(edtaca_list)\n",
+    "prot_length = len(prot_list)\n",
+    "blank_length = len(blank_list)\n",
+    "\n",
+    "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
+    "\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    \n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    err_style[\"color\"] = color_order[i]\n",
+    "\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values,y_values,**style)\n",
+    "    ax.errorbar(x=x_values,\n",
+    "                y=y_values,\n",
+    "                yerr=y_err,\n",
+    "                **err_style)\n",
+    "\n",
+    "    ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n",
+    "\n",
+    "ax.set_ylim((-100,10))\n",
+    "\n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4d89a05-fb93-4255-bf26-e39db481e303",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "style = {\"s\":50,\n",
+    "         \"facecolor\":\"none\",\n",
+    "         \"edgecolor\":\"black\"}\n",
+    "err_style = {\"lw\":0,\n",
+    "             \"elinewidth\":1,\n",
+    "             \"capsize\":2}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
+    "\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    \n",
+    "    style[\"edgecolor\"] = \"blue\"\n",
+    "    err_style[\"color\"] = \"red\"\n",
+    "\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values,y_values,**style)\n",
+    "    ax.errorbar(x=x_values,\n",
+    "                y=y_values,\n",
+    "                #yerr=y_err,\n",
+    "                **err_style)\n",
+    "\n",
+    "    ax.plot(x_values,this_y_calc,'-',color=\"red\")\n",
+    "\n",
+    "ax.set_ylim((-100,10))\n",
+    "\n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7875819c-4e89-4de4-a8c0-bdafe99c819a",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Print column names for one of each type of experiment\n",
+    "print(\"Blank experiment columns:\")\n",
+    "print(blank_list[0].expt_concs.columns)\n",
+    "print(\"\\nEDTA-Ca experiment columns:\")\n",
+    "print(edtaca_list[0].expt_concs.columns)\n",
+    "print(\"\\nProtein experiment columns:\")\n",
+    "print(prot_list[0].expt_concs.columns)\n",
+    "\n",
+    "# Check data structure\n",
+    "print(\"\\nSample of concentration data:\")\n",
+    "print(prot_list[0].expt_concs.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "327fc64a-a64e-4c18-9727-b2b2a90c5cc3",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Plot settings\n",
+    "style = {\"s\": 50, \"facecolor\": \"none\"}\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "# Get fitted parameters and calculate theoretical heats\n",
+    "params = np.array(f.fit_df[\"estimate\"])\n",
+    "y_calc = gm.model(params)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, figsize=(8,6))\n",
+    "\n",
+    "# Get overall y range from experimental data to set limits\n",
+    "y_min = gm.as_df[\"y_obs\"].min()\n",
+    "y_max = gm.as_df[\"y_obs\"].max()\n",
+    "y_range = y_max - y_min\n",
+    "y_limits = [y_min - 15*y_range, y_max + 15*y_range]\n",
+    "\n",
+    "# Plot each experiment\n",
+    "for i in np.unique(gm.as_df.expt_id):\n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    \n",
+    "    # Get data for this experiment using gm.as_df\n",
+    "    mask = gm.as_df.expt_id == i\n",
+    "    this_df = gm.as_df.loc[mask,:]\n",
+    "    \n",
+    "    # Get theoretical heats for this experiment\n",
+    "    heats = y_calc[mask]\n",
+    "    # Calculate injection-to-injection differences\n",
+    "    heat_diffs = np.diff(heats, prepend=heats[0])\n",
+    "    \n",
+    "    # Get experimental points\n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = this_df[\"y_obs\"]\n",
+    "    \n",
+    "    # Plot experimental points\n",
+    "    ax.scatter(x_values, y_values, \n",
+    "              **style,\n",
+    "              label=f'Expt {i} (data)')\n",
+    "    \n",
+    "    # Plot theoretical curve using differences\n",
+    "    ax.plot(x_values, heat_diffs, '-',\n",
+    "            color=color_order[i],\n",
+    "            label=f'Expt {i} (fit)')\n",
+    "\n",
+    "ax.set_xlabel('Cumulative Injection')\n",
+    "ax.set_ylabel('Heat per injection (μcal)')\n",
+    "ax.set_ylim(y_limits)\n",
+    "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d72d8bfd-d925-445e-967d-4f6603621a2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_corner(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_summary(f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81dc68e5-756e-4b53-8b09-704f935525e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# No error consideration\n",
+    "style = {\n",
+    "    \"s\": 50,\n",
+    "    \"facecolor\": \"none\",\n",
+    "    \"edgecolor\": \"black\"\n",
+    "}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "edtaca_length = len(edtaca_list)\n",
+    "prot_length = len(prot_list)\n",
+    "blank_length = len(blank_list)\n",
+    "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n",
+    "\n",
+    "fig, ax = plt.subplots(1, figsize=(6,6))\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values, y_values, **style)\n",
+    "    ax.plot(x_values, this_y_calc, '-', color=color_order[i])\n",
+    "    \n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc9b3969-cf7e-46f4-a467-1c128f45a228",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/genericmodelimplementation_8Cycle.ipynb b/notebooks/genericmodelimplementation_8Cycle.ipynb
new file mode 100644
index 0000000..d85e627
--- /dev/null
+++ b/notebooks/genericmodelimplementation_8Cycle.ipynb
@@ -0,0 +1,1357 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b11cea11-6bb7-4286-9550-6a47f3c017ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import dataprob\n",
+    "import copy\n",
+    "import linkage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "75839bf7-0265-4c1b-9bdb-770c1d2fb2f1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "### Load Experimental Data\n",
+    "cell_vol = 201.3\n",
+    "\n",
+    "## EDTA --> Protein + Ca\n",
+    "prot1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4HIGHRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "prot2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4SUPERDUPERRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "prot3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240823\\3mMEDTAto50uMhA4.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "prot4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA4.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "prot5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA42.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot5.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "prot6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA43.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot6.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## Ca -> EDTA + Protein\n",
+    "\n",
+    "reprot1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA50uMhA4.csv\",\n",
+    "                                      cell_contents={\"ET\":50e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"CT\":500e-6},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "reprot1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "reprot2 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCato50uMEDTA50uMhA4.csv\",\n",
+    "                                      cell_contents={\"ET\":50e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"CT\":1e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "reprot2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "## EDTA --> Buffer\n",
+    "\n",
+    "blank1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa2.csv\",\n",
+    "                                        cell_contents={\"CT\":0},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "blank1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "blank2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa3.csv\",\n",
+    "                                        cell_contents={\"CT\":0},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "blank2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## Ca --> Buffer\n",
+    "\n",
+    "blank3 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "blank3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "blank4 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer2.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "blank4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## Ca --> EDTA\n",
+    "\n",
+    "caedta1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA.csv\",\n",
+    "                                      cell_contents={\"ET\":50e-6},\n",
+    "                                      syringe_contents={\"CT\":500e-6},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "caedta1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## EDTA --> Ca\n",
+    "\n",
+    "edtaca1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3mMEDTAto500uMCa.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "edtaca2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3p5mMEDTAto500uMCaCl2HHR.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "edtaca3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240915\\3p5mMEDTAto500uMCaCl2lowres.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "edtaca4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto500uMCaLOWRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtaca5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca5.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtaca6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca6.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtaca7 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_3.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca7.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## CD Experiments\n",
+    "\n",
+    "# cd1 = linkage.experiment.Experiment(r\"\",\n",
+    "#                                       cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "#                                       syringe_contents={\"ET\":2e-3},\n",
+    "#                                       cell_volume=cell_vol,\n",
+    "#                                       conc_to_float=\"ET\")\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "973ecc70-baf0-4fc2-a25a-047d67b0da51",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===== GENERIC BINDING MODEL SUMMARY =====\n",
+      "Constants: ['KE', 'K1', 'K2', 'K3', 'K4', 'KI1', 'KI2', 'KT1', 'KT2', 'KT3']\n",
+      "Microspecies: ['A', 'AC1', 'AC2', 'AC3', 'AC4', 'C', 'E', 'EC', 'I', 'IC1', 'IC2']\n",
+      "Macrospecies: ['AT', 'CT', 'ET']\n",
+      "Equilibria:\n",
+      "  E + C -> EC; KE\n",
+      "  A + C -> AC1; K1\n",
+      "  AC1 + C -> AC2; K2\n",
+      "  AC2 + C -> AC3; K3\n",
+      "  AC3 + C -> AC4; K4\n",
+      "  I + C -> IC1; KI1\n",
+      "  IC1 + C -> IC2; KI2\n",
+      "  A -> I; KT1\n",
+      "  AC1 -> IC1; KT2\n",
+      "  AC2 -> IC2; KT3\n",
+      "Final conservation equation: 4*AT*C**4*K1*K2*K3*K4/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) + 6*AT*C**3*K1*K2*K3/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) + 2*AT*C**2*K1*K2*KT3/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) + 2*AT*C**2*K1*K2/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) + 2*AT*C*K1*KT2/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) + 2*AT*C*K1/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) + C*ET*KE/(C*KE + 1) + C - CT\n",
+      "===== END SUMMARY =====\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "#### Create model instance\n",
+    "#Full Lists\n",
+    "blank_list = [blank1, blank2]\n",
+    "edtaca_list = [edtaca1, edtaca2, edtaca3, edtaca4, edtaca5, edtaca6, edtaca7, caedta1]\n",
+    "prot_list = [prot1, prot2, prot3, prot4, prot5, prot6]#, reprot1, reprot2]\n",
+    "\n",
+    "#Combine experiment types into one list\n",
+    "expt_list = blank_list + edtaca_list + prot_list\n",
+    "\n",
+    "\n",
+    "# Read the model specification from file\n",
+    "spec_file_path = r\"C:\\Users\\willi\\linkage\\src\\linkage\\model_specs\\hA4_8Cycle.txt\"\n",
+    "\n",
+    "# Read spec\n",
+    "with open(spec_file_path, 'r') as f:\n",
+    "    model_spec = f.read()\n",
+    "\n",
+    "# Create GlobalModel with spec\n",
+    "gm = linkage.GlobalModel(\n",
+    "    model_name=\"GenericBindingModel\",\n",
+    "    model_spec=model_spec,\n",
+    "    expt_list=expt_list\n",
+    ")\n",
+    "\n",
+    "#Setup dataprob\n",
+    "f = dataprob.setup(gm.model_normalized,\n",
+    "                   method=\"ml\",\n",
+    "                   vector_first_arg=True,\n",
+    "                   fit_parameters=gm.parameter_names)\n",
+    "\n",
+    "# Access the binding model through the GlobalModel\n",
+    "gm._bm.print_summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "10064dc1-cb03-4ea7-b107-2dba82d6ba2f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE0.0False-infinfNaNNaN
K1K10.0False-infinfNaNNaN
K2K20.0False-infinfNaNNaN
K3K30.0False-infinfNaNNaN
K4K40.0False-infinfNaNNaN
KI1KI10.0False-infinfNaNNaN
KI2KI20.0False-infinfNaNNaN
KT1KT10.0False-infinfNaNNaN
KT2KT20.0False-infinfNaNNaN
KT3KT30.0False-infinfNaNNaN
dH_EdH_E0.0False-infinfNaNNaN
dH_1dH_10.0False-infinfNaNNaN
dH_2dH_20.0False-infinfNaNNaN
dH_3dH_30.0False-infinfNaNNaN
dH_4dH_40.0False-infinfNaNNaN
dH_I1dH_I10.0False-infinfNaNNaN
dH_I2dH_I20.0False-infinfNaNNaN
dH_T1dH_T10.0False-infinfNaNNaN
dH_T2dH_T20.0False-infinfNaNNaN
dH_T3dH_T30.0False-infinfNaNNaN
nuisance_dil_CTnuisance_dil_CT0.0False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ET0.0False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_10_ET_fudgenuisance_expt_10_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_11_ET_fudgenuisance_expt_11_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_12_ET_fudgenuisance_expt_12_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_13_ET_fudgenuisance_expt_13_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_14_ET_fudgenuisance_expt_14_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_15_ET_fudgenuisance_expt_15_ET_fudge0.0False-infinfNaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                                name  guess  fixed  \\\n",
+       "name                                                                 \n",
+       "KE                                                KE    0.0  False   \n",
+       "K1                                                K1    0.0  False   \n",
+       "K2                                                K2    0.0  False   \n",
+       "K3                                                K3    0.0  False   \n",
+       "K4                                                K4    0.0  False   \n",
+       "KI1                                              KI1    0.0  False   \n",
+       "KI2                                              KI2    0.0  False   \n",
+       "KT1                                              KT1    0.0  False   \n",
+       "KT2                                              KT2    0.0  False   \n",
+       "KT3                                              KT3    0.0  False   \n",
+       "dH_E                                            dH_E    0.0  False   \n",
+       "dH_1                                            dH_1    0.0  False   \n",
+       "dH_2                                            dH_2    0.0  False   \n",
+       "dH_3                                            dH_3    0.0  False   \n",
+       "dH_4                                            dH_4    0.0  False   \n",
+       "dH_I1                                          dH_I1    0.0  False   \n",
+       "dH_I2                                          dH_I2    0.0  False   \n",
+       "dH_T1                                          dH_T1    0.0  False   \n",
+       "dH_T2                                          dH_T2    0.0  False   \n",
+       "dH_T3                                          dH_T3    0.0  False   \n",
+       "nuisance_dil_CT                      nuisance_dil_CT    0.0  False   \n",
+       "nuisance_dil_ET                      nuisance_dil_ET    0.0  False   \n",
+       "nuisance_expt_0_ET_fudge    nuisance_expt_0_ET_fudge    0.0  False   \n",
+       "nuisance_expt_1_ET_fudge    nuisance_expt_1_ET_fudge    0.0  False   \n",
+       "nuisance_expt_2_ET_fudge    nuisance_expt_2_ET_fudge    0.0  False   \n",
+       "nuisance_expt_3_ET_fudge    nuisance_expt_3_ET_fudge    0.0  False   \n",
+       "nuisance_expt_4_ET_fudge    nuisance_expt_4_ET_fudge    0.0  False   \n",
+       "nuisance_expt_5_ET_fudge    nuisance_expt_5_ET_fudge    0.0  False   \n",
+       "nuisance_expt_6_ET_fudge    nuisance_expt_6_ET_fudge    0.0  False   \n",
+       "nuisance_expt_7_ET_fudge    nuisance_expt_7_ET_fudge    0.0  False   \n",
+       "nuisance_expt_8_ET_fudge    nuisance_expt_8_ET_fudge    0.0  False   \n",
+       "nuisance_expt_9_ET_fudge    nuisance_expt_9_ET_fudge    0.0  False   \n",
+       "nuisance_expt_10_ET_fudge  nuisance_expt_10_ET_fudge    0.0  False   \n",
+       "nuisance_expt_11_ET_fudge  nuisance_expt_11_ET_fudge    0.0  False   \n",
+       "nuisance_expt_12_ET_fudge  nuisance_expt_12_ET_fudge    0.0  False   \n",
+       "nuisance_expt_13_ET_fudge  nuisance_expt_13_ET_fudge    0.0  False   \n",
+       "nuisance_expt_14_ET_fudge  nuisance_expt_14_ET_fudge    0.0  False   \n",
+       "nuisance_expt_15_ET_fudge  nuisance_expt_15_ET_fudge    0.0  False   \n",
+       "\n",
+       "                           lower_bound  upper_bound  prior_mean  prior_std  \n",
+       "name                                                                        \n",
+       "KE                                -inf          inf         NaN        NaN  \n",
+       "K1                                -inf          inf         NaN        NaN  \n",
+       "K2                                -inf          inf         NaN        NaN  \n",
+       "K3                                -inf          inf         NaN        NaN  \n",
+       "K4                                -inf          inf         NaN        NaN  \n",
+       "KI1                               -inf          inf         NaN        NaN  \n",
+       "KI2                               -inf          inf         NaN        NaN  \n",
+       "KT1                               -inf          inf         NaN        NaN  \n",
+       "KT2                               -inf          inf         NaN        NaN  \n",
+       "KT3                               -inf          inf         NaN        NaN  \n",
+       "dH_E                              -inf          inf         NaN        NaN  \n",
+       "dH_1                              -inf          inf         NaN        NaN  \n",
+       "dH_2                              -inf          inf         NaN        NaN  \n",
+       "dH_3                              -inf          inf         NaN        NaN  \n",
+       "dH_4                              -inf          inf         NaN        NaN  \n",
+       "dH_I1                             -inf          inf         NaN        NaN  \n",
+       "dH_I2                             -inf          inf         NaN        NaN  \n",
+       "dH_T1                             -inf          inf         NaN        NaN  \n",
+       "dH_T2                             -inf          inf         NaN        NaN  \n",
+       "dH_T3                             -inf          inf         NaN        NaN  \n",
+       "nuisance_dil_CT                   -inf          inf         NaN        NaN  \n",
+       "nuisance_dil_ET                   -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge          -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_10_ET_fudge         -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_11_ET_fudge         -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_12_ET_fudge         -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_13_ET_fudge         -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_14_ET_fudge         -inf          inf         NaN        NaN  \n",
+       "nuisance_expt_15_ET_fudge         -inf          inf         NaN        NaN  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a8e9c307-8be7-4bbc-a6ce-d26c5137978a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Reasonable param_df changes, should +/- inf bounds be changed at instantiation of param_df to be actual numbers and not infs. maybe min/max float?\n",
+    "\n",
+    "# Nuisance Params\n",
+    "# Get all parameter names containing 'nuisance_expt'\n",
+    "fudge_params = [col for col in f.param_df.index if 'nuisance_expt' in col]\n",
+    "\n",
+    "# Link all fudge parameters (except 0) to the first one, set first one = 1.1\n",
+    "for param in fudge_params:\n",
+    "    f.param_df.loc[param, 'guess'] = 1.1\n",
+    "    f.param_df.loc[param, 'fixed'] = True\n",
+    "    f.param_df.loc[param, 'lower_bound'] = -2\n",
+    "    f.param_df.loc[param, 'upper_bound'] = 2\n",
+    "\n",
+    "# ## K bounds\n",
+    "\n",
+    "eq_constants = [col for col in f.param_df.index if 'K' in col]\n",
+    "for param in eq_constants:\n",
+    "    f.param_df.loc[param, 'upper_bound'] = 30\n",
+    "    f.param_df.loc[param, 'lower_bound'] = -30\n",
+    "\n",
+    "# Heats\n",
+    "heat_constants = [col for col in f.param_df.index if 'dH_' in col]\n",
+    "for param in heat_constants:\n",
+    "    f.param_df.loc[param, 'upper_bound'] = 30000\n",
+    "    f.param_df.loc[param, 'lower_bound'] = -30000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "059ebc3b-c8f3-4688-a5cf-4b8fc3cd5ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Parameters from CaEDTA fitting\n",
+    "\n",
+    "# EDTA K/dH\n",
+    "f.param_df.loc[\"KE\",\"guess\"] = 16.18\n",
+    "f.param_df.loc[\"KE\",\"upper_bound\"] = 16.20\n",
+    "f.param_df.loc[\"KE\",\"lower_bound\"] = 16.16\n",
+    "f.param_df.loc[\"KE\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"dH_E\",\"guess\"] = -10902\n",
+    "f.param_df.loc[\"dH_E\",\"upper_bound\"] = -10800\n",
+    "f.param_df.loc[\"dH_E\",\"lower_bound\"] = -11000\n",
+    "f.param_df.loc[\"dH_E\",\"fixed\"] = True\n",
+    "\n",
+    "#Dilution Params\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"guess\"] = -269.505231\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"upper_bound\"] = 1000\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"lower_bound\"] = -1000\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"guess\"] = -19.554765\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"upper_bound\"] = 1000\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"lower_bound\"] = -1000\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"fixed\"] = True\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ac7eaa7-d428-497a-8bb9-1e6d36580023",
+   "metadata": {
+    "editable": true,
+    "scrolled": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "## Parameter Specs\n",
+    "\n",
+    "f.param_df.loc[\"K1\",\"guess\"] = 10\n",
+    "f.param_df.loc[\"K1\",\"upper_bound\"] = 20\n",
+    "f.param_df.loc[\"K1\",\"lower_bound\"] = 7\n",
+    "f.param_df.loc[\"K1\",\"fixed\"] = False\n",
+    "\n",
+    "f.param_df.loc[\"K2\",\"guess\"] = 7\n",
+    "f.param_df.loc[\"K2\",\"upper_bound\"] = 20\n",
+    "f.param_df.loc[\"K2\",\"lower_bound\"] = 7\n",
+    "f.param_df.loc[\"K2\",\"fixed\"] = False\n",
+    "\n",
+    "f.param_df.loc[\"K3\",\"guess\"] = 7\n",
+    "f.param_df.loc[\"K3\",\"upper_bound\"] = 11\n",
+    "f.param_df.loc[\"K3\",\"lower_bound\"] = 2\n",
+    "f.param_df.loc[\"K3\",\"fixed\"] = False\n",
+    "\n",
+    "f.param_df.loc[\"K4\",\"guess\"] = 7\n",
+    "f.param_df.loc[\"K4\",\"upper_bound\"] = 11\n",
+    "f.param_df.loc[\"K4\",\"lower_bound\"] = 2\n",
+    "f.param_df.loc[\"K4\", \"fixed\"] = False\n",
+    "\n",
+    "\n",
+    "# # ### Enthalpy Guesses\n",
+    "\n",
+    "f.param_df.loc[\"dH_1\",\"guess\"] = -1000\n",
+    "f.param_df.loc[\"dH_1\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_1\",\"lower_bound\"] = -10000\n",
+    "\n",
+    "f.param_df.loc[\"dH_2\",\"guess\"] = 1000\n",
+    "f.param_df.loc[\"dH_2\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_2\",\"lower_bound\"] = -10000\n",
+    "\n",
+    "f.param_df.loc[\"dH_3\",\"guess\"] = -100\n",
+    "f.param_df.loc[\"dH_3\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_3\",\"lower_bound\"] = -10000\n",
+    "\n",
+    "f.param_df.loc[\"dH_4\",\"guess\"] = 1000\n",
+    "f.param_df.loc[\"dH_4\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_4\",\"lower_bound\"] = -10000\n",
+    "\n",
+    "\n",
+    "# f.param_df.loc[\"\",\"parent\"] = ''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64e5faa0-8977-402d-9d4a-0bb635afddec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5a86763-1f1d-434f-ab80-a3f2437aefac",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "##### Run fit\n",
+    "\n",
+    "f.fit(\n",
+    "      y_obs=gm.y_obs_normalized,\n",
+    "      y_std=gm.y_std_normalized,\n",
+    "      #max_convergence_cycles=1,\n",
+    "      #use_ml_guess=False,\n",
+    "      #num_steps=800,\n",
+    "      #num_walkers=200, # number of markov chains to use in the analysis, default=100       \n",
+    "      method='trf',  # Algorithm to use for optimization\n",
+    "      tr_solver = 'exact',\n",
+    "      #jac='3-point',  # Method for computing the Jacobian matrix\n",
+    "      ftol=1e-10,  # Tolerance for termination by the change of the cost function\n",
+    "      xtol=1e-7,  # Tolerance for termination by the change of the independent variables\n",
+    "      #gtol=1e-8,  # Tolerance for termination by the norm of the gradient\n",
+    "      #x_scale='jac',  # Scaling of the variables\n",
+    "      #loss='arctan',  # Loss function for dealing with outliers\n",
+    "      #f_scale=0.01  # Soft margin between inlier and outlier residuals\n",
+    "      #max_nfev=None,  # Maximum number of function evaluations\n",
+    "      #verbose=2  # Level of algorithm's verbosity\n",
+    "     )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a10f7f1-4d41-4f27-ac56-46c6afd61660",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pd.set_option('display.float_format', lambda x: '%.6f' % x)\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aea1cd7c-d33e-4145-b0de-554d367ab533",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "# Create figure with reasonable size\n",
+    "plt.figure(figsize=(12, 8))\n",
+    "# Plot each column against the index\n",
+    "for column in concs_df.columns:\n",
+    "    plt.plot(concs_df.index[3472:3531], concs_df[column][3472:3531], label=column)\n",
+    "    \n",
+    "# Add labels and legend\n",
+    "plt.xlabel('Step Number')\n",
+    "plt.ylabel('Concentration')\n",
+    "plt.title('Species Concentrations')\n",
+    "plt.legend()\n",
+    "# Show grid\n",
+    "plt.grid(True)\n",
+    "# Display the plot\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd7e7f25-2292-4a3d-a51c-5b7a3a0801d6",
+   "metadata": {},
+   "source": [
+    "## f.fit_quality"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1987676f-1c6a-44a3-995e-44af42226172",
+   "metadata": {},
+   "source": [
+    "#### Plot results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a",
+   "metadata": {
+    "editable": true,
+    "scrolled": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "style = {\"s\":50,\n",
+    "         \"facecolor\":\"none\",\n",
+    "         \"edgecolor\":\"black\"}\n",
+    "err_style = {\"lw\":0,\n",
+    "             \"elinewidth\":1,\n",
+    "             \"capsize\":2}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "edtaca_length = len(edtaca_list)\n",
+    "prot_length = len(prot_list)\n",
+    "blank_length = len(blank_list)\n",
+    "\n",
+    "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
+    "\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    \n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    err_style[\"color\"] = color_order[i]\n",
+    "\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values,y_values,**style)\n",
+    "    ax.errorbar(x=x_values,\n",
+    "                y=y_values,\n",
+    "                #yerr=y_err,\n",
+    "                **err_style)\n",
+    "\n",
+    "    ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n",
+    "\n",
+    "ax.set_ylim((-100,10))\n",
+    "\n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4d89a05-fb93-4255-bf26-e39db481e303",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "style = {\"s\":50,\n",
+    "         \"facecolor\":\"none\",\n",
+    "         \"edgecolor\":\"black\"}\n",
+    "err_style = {\"lw\":0,\n",
+    "             \"elinewidth\":1,\n",
+    "             \"capsize\":2}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
+    "\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    \n",
+    "    style[\"edgecolor\"] = \"blue\"\n",
+    "    err_style[\"color\"] = \"red\"\n",
+    "\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values,y_values,**style)\n",
+    "    ax.errorbar(x=x_values,\n",
+    "                y=y_values,\n",
+    "                #yerr=y_err,\n",
+    "                **err_style)\n",
+    "\n",
+    "    ax.plot(x_values,this_y_calc,'-',color=\"red\")\n",
+    "\n",
+    "ax.set_ylim((-100,10))\n",
+    "\n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7875819c-4e89-4de4-a8c0-bdafe99c819a",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Print column names for one of each type of experiment\n",
+    "print(\"Blank experiment columns:\")\n",
+    "print(blank_list[0].expt_concs.columns)\n",
+    "print(\"\\nEDTA-Ca experiment columns:\")\n",
+    "print(edtaca_list[0].expt_concs.columns)\n",
+    "print(\"\\nProtein experiment columns:\")\n",
+    "print(prot_list[0].expt_concs.columns)\n",
+    "\n",
+    "# Check data structure\n",
+    "print(\"\\nSample of concentration data:\")\n",
+    "print(prot_list[0].expt_concs.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "327fc64a-a64e-4c18-9727-b2b2a90c5cc3",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Plot settings\n",
+    "style = {\"s\": 50, \"facecolor\": \"none\"}\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "# Get fitted parameters and calculate theoretical heats\n",
+    "params = np.array(f.fit_df[\"estimate\"])\n",
+    "y_calc = gm.model(params)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, figsize=(8,6))\n",
+    "\n",
+    "# Get overall y range from experimental data to set limits\n",
+    "y_min = gm.as_df[\"y_obs\"].min()\n",
+    "y_max = gm.as_df[\"y_obs\"].max()\n",
+    "y_range = y_max - y_min\n",
+    "y_limits = [y_min - 15*y_range, y_max + 15*y_range]\n",
+    "\n",
+    "# Plot each experiment\n",
+    "for i in np.unique(gm.as_df.expt_id):\n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    \n",
+    "    # Get data for this experiment using gm.as_df\n",
+    "    mask = gm.as_df.expt_id == i\n",
+    "    this_df = gm.as_df.loc[mask,:]\n",
+    "    \n",
+    "    # Get theoretical heats for this experiment\n",
+    "    heats = y_calc[mask]\n",
+    "    # Calculate injection-to-injection differences\n",
+    "    heat_diffs = np.diff(heats, prepend=heats[0])\n",
+    "    \n",
+    "    # Get experimental points\n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = this_df[\"y_obs\"]\n",
+    "    \n",
+    "    # Plot experimental points\n",
+    "    ax.scatter(x_values, y_values, \n",
+    "              **style,\n",
+    "              label=f'Expt {i} (data)')\n",
+    "    \n",
+    "    # Plot theoretical curve using differences\n",
+    "    ax.plot(x_values, heat_diffs, '-',\n",
+    "            color=color_order[i],\n",
+    "            label=f'Expt {i} (fit)')\n",
+    "\n",
+    "ax.set_xlabel('Cumulative Injection')\n",
+    "ax.set_ylabel('Heat per injection (μcal)')\n",
+    "ax.set_ylim(y_limits)\n",
+    "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d72d8bfd-d925-445e-967d-4f6603621a2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_corner(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_summary(f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81dc68e5-756e-4b53-8b09-704f935525e7",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# No error consideration\n",
+    "style = {\n",
+    "    \"s\": 50,\n",
+    "    \"facecolor\": \"none\",\n",
+    "    \"edgecolor\": \"black\"\n",
+    "}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "edtaca_length = len(edtaca_list)\n",
+    "prot_length = len(prot_list)\n",
+    "blank_length = len(blank_list)\n",
+    "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n",
+    "\n",
+    "fig, ax = plt.subplots(1, figsize=(6,6))\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values, y_values, **style)\n",
+    "    ax.plot(x_values, this_y_calc, '-', color=color_order[i])\n",
+    "    \n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc9b3969-cf7e-46f4-a467-1c128f45a228",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/genericmodelimplementation_CaEDTA.ipynb b/notebooks/genericmodelimplementation_CaEDTA.ipynb
new file mode 100644
index 0000000..bf81d43
--- /dev/null
+++ b/notebooks/genericmodelimplementation_CaEDTA.ipynb
@@ -0,0 +1,1275 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b11cea11-6bb7-4286-9550-6a47f3c017ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import dataprob\n",
+    "import copy\n",
+    "import linkage\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "75839bf7-0265-4c1b-9bdb-770c1d2fb2f1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#### Load Experimental Data\n",
+    "\n",
+    "## EDTA --> Buffer\n",
+    "\n",
+    "cell_vol = 201.3\n",
+    "sd = 0.1\n",
+    "\n",
+    "## EDTA --> Buffer\n",
+    "\n",
+    "blank1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa2.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "blank1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "blank2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa3.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "blank2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## Ca --> Buffer\n",
+    "\n",
+    "blank3 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "blank3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "blank4 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer2.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "blank4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## EDTA --> Ca\n",
+    "\n",
+    "edtaca1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3mMEDTAto500uMCa.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=sd)\n",
+    "\n",
+    "\n",
+    "edtaca2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240915\\3p5mMEDTAto500uMCaCl2lowres.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=sd)\n",
+    "\n",
+    "\n",
+    "edtaca3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto500uMCaLOWRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=sd)\n",
+    "\n",
+    "edtaca4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=sd)\n",
+    "\n",
+    "edtaca5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca5.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=sd)\n",
+    "\n",
+    "edtaca6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_3.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca6.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=sd)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "973ecc70-baf0-4fc2-a25a-047d67b0da51",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO: Analytical Jacobian was successfully generated for the binding model.\n"
+     ]
+    }
+   ],
+   "source": [
+    "#### Create model instance\n",
+    "#Full Lists\n",
+    "blank_list = [blank1, blank2, blank3, blank4]\n",
+    "edtaca_list = [edtaca1, edtaca2, edtaca3, edtaca4, edtaca5, edtaca6]\n",
+    "\n",
+    "\n",
+    "#Combine experiment types into one list\n",
+    "expt_list = blank_list + edtaca_list\n",
+    "\n",
+    "\n",
+    "# Read the model specification from file\n",
+    "spec_file_path = r\"C:\\Users\\willi\\linkage\\src\\linkage\\model_specs\\CaEDTA.txt\"\n",
+    "\n",
+    "# Read spec\n",
+    "with open(spec_file_path, 'r') as f:\n",
+    "    model_spec = f.read()\n",
+    "\n",
+    "# Create GlobalModel with spec\n",
+    "gm = linkage.GlobalModel(\n",
+    "    model_name=\"GenericBindingModel\",\n",
+    "    model_spec=model_spec,\n",
+    "    expt_list=expt_list\n",
+    ")\n",
+    "\n",
+    "#Setup dataprob\n",
+    "f = dataprob.setup(gm.model_normalized,\n",
+    "                   method=\"ml\",\n",
+    "                   vector_first_arg=True,\n",
+    "                   fit_parameters=gm.parameter_names)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "10064dc1-cb03-4ea7-b107-2dba82d6ba2f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE0.0False-infinfNaNNaN
dH_EdH_E0.0False-infinfNaNNaN
nuisance_dil_CTnuisance_dil_CT0.0False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ET0.0False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_2_CT_fudgenuisance_expt_2_CT_fudge0.0False-infinfNaNNaN
nuisance_expt_3_CT_fudgenuisance_expt_3_CT_fudge0.0False-infinfNaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge0.0False-infinfNaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name  guess  fixed  lower_bound  \\\n",
+       "name                                                                            \n",
+       "KE                                              KE    0.0  False         -inf   \n",
+       "dH_E                                          dH_E    0.0  False         -inf   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT    0.0  False         -inf   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET    0.0  False         -inf   \n",
+       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_2_CT_fudge  nuisance_expt_2_CT_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_3_CT_fudge  nuisance_expt_3_CT_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge    0.0  False         -inf   \n",
+       "\n",
+       "                          upper_bound  prior_mean  prior_std  \n",
+       "name                                                          \n",
+       "KE                                inf         NaN        NaN  \n",
+       "dH_E                              inf         NaN        NaN  \n",
+       "nuisance_dil_CT                   inf         NaN        NaN  \n",
+       "nuisance_dil_ET                   inf         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_2_CT_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_3_CT_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge          inf         NaN        NaN  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a8e9c307-8be7-4bbc-a6ce-d26c5137978a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE16.18False14.018.0NaNNaN
dH_EdH_E-11000.00False-15000.0-5000.0NaNNaN
nuisance_dil_CTnuisance_dil_CT0.00False-5000.05000.0NaNNaN
nuisance_dil_ETnuisance_dil_ET0.00False-5000.05000.0NaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_2_CT_fudgenuisance_expt_2_CT_fudge1.10True0.81.2NaNNaN
nuisance_expt_3_CT_fudgenuisance_expt_3_CT_fudge1.10True0.81.2NaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge1.10True0.81.2NaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge1.10True0.81.2NaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name     guess  fixed  \\\n",
+       "name                                                                  \n",
+       "KE                                              KE     16.18  False   \n",
+       "dH_E                                          dH_E -11000.00  False   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT      0.00  False   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET      0.00  False   \n",
+       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge      1.10   True   \n",
+       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge      1.10   True   \n",
+       "nuisance_expt_2_CT_fudge  nuisance_expt_2_CT_fudge      1.10   True   \n",
+       "nuisance_expt_3_CT_fudge  nuisance_expt_3_CT_fudge      1.10   True   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.10   True   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.10   True   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge      1.10   True   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge      1.10   True   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge      1.10   True   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge      1.10   True   \n",
+       "\n",
+       "                          lower_bound  upper_bound  prior_mean  prior_std  \n",
+       "name                                                                       \n",
+       "KE                               14.0         18.0         NaN        NaN  \n",
+       "dH_E                         -15000.0      -5000.0         NaN        NaN  \n",
+       "nuisance_dil_CT               -5000.0       5000.0         NaN        NaN  \n",
+       "nuisance_dil_ET               -5000.0       5000.0         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_2_CT_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_3_CT_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge          0.8          1.2         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge          0.8          1.2         NaN        NaN  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "param_configs = {\n",
+    "    \"KE\": {\n",
+    "        \"guess\": 16.18,          # ln(K) from previous knowledge\n",
+    "        \"lower_bound\": 14.0,     # K ~ 1.2e6 M^-1\n",
+    "        \"upper_bound\": 18.0,     # K ~ 6.5e7 M^-1\n",
+    "    },\n",
+    "    \"dH_E\": {\n",
+    "        \"guess\": -11000,         # dH in cal/mol (~ -11 kcal/mol)\n",
+    "        \"lower_bound\": -15000,   # -15 kcal/mol\n",
+    "        \"upper_bound\": -5000,    # -5 kcal/mol\n",
+    "    },\n",
+    "    \"nuisance_dil_CT\": {\n",
+    "        \"guess\": 0.0,\n",
+    "        \"lower_bound\": -5000,\n",
+    "        \"upper_bound\": 5000,\n",
+    "    },\n",
+    "    \"nuisance_dil_ET\": {\n",
+    "        \"guess\": 0.0,\n",
+    "        \"lower_bound\": -5000,\n",
+    "        \"upper_bound\": 5000,\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "for param_name, settings in param_configs.items():\n",
+    "    if param_name in f.param_df.index:\n",
+    "        for key, value in settings.items():\n",
+    "            f.param_df.loc[param_name, key] = value\n",
+    "\n",
+    "fudge_params = [name for name in f.param_df.index if 'nuisance_expt' in name]\n",
+    "for param_name in fudge_params:\n",
+    "    f.param_df.loc[param_name, 'guess'] = 1.1\n",
+    "    f.param_df.loc[param_name, 'fixed'] = True\n",
+    "    f.param_df.loc[param_name, 'lower_bound'] = 0.8\n",
+    "    f.param_df.loc[param_name, 'upper_bound'] = 1.2\n",
+    "\n",
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c5a86763-1f1d-434f-ab80-a3f2437aefac",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO: Analytical Jacobian found in the model. Using for optimization.\n",
+      "   Iteration     Total nfev        Cost      Cost reduction    Step norm     Optimality   \n",
+      "       0              1         4.3225e+07                                    9.04e+09    \n",
+      "       1              2         2.2847e+07      2.04e+07       3.24e+02       5.96e+09    \n",
+      "       2              4         2.2626e+07      2.21e+05       1.18e+01       1.76e+09    \n",
+      "       3              6         2.2613e+07      1.26e+04       2.97e+00       9.24e+08    \n",
+      "       4              8         2.2609e+07      4.52e+03       7.07e-01       2.27e+08    \n",
+      "       5             10         2.2609e+07      1.97e+02       3.34e-01       1.14e+08    \n",
+      "       6             12         2.2609e+07      6.28e+01       8.35e-02       2.95e+07    \n",
+      "       7             14         2.2609e+07      3.09e+00       2.09e-02       8.43e+06    \n",
+      "       8             16         2.2609e+07      1.93e-01       1.26e-03       4.66e+06    \n",
+      "       9             17         2.2609e+07      1.84e-02       3.17e-04       3.83e+06    \n",
+      "      10             18         2.2609e+07      3.09e-03       7.95e-05       3.62e+06    \n",
+      "      11             19         2.2609e+07      6.83e-04       1.99e-05       3.57e+06    \n",
+      "      12             20         2.2609e+07      1.65e-04       4.97e-06       3.56e+06    \n",
+      "`xtol` termination condition is satisfied.\n",
+      "Function evaluations 20, initial cost 4.3225e+07, final cost 2.2609e+07, first-order optimality 3.56e+06.\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ML FITTER FUNCTION CALL (Requires method=\"ml\" in the dataprob fitter setup)\n",
+    "\n",
+    "f.fit(\n",
+    "    y_obs=gm.y_obs_normalized,\n",
+    "    y_std=gm.y_std_normalized,\n",
+    "\n",
+    "    # --- Core Arguments for the Optimizer ---\n",
+    "    method='trf',          # Trust Region Reflective is good for bounded problems.\n",
+    "\n",
+    "    # --- Tolerances ---\n",
+    "    # Loosen ftol/gtol slightly to handle flat regions, keep xtol tight.\n",
+    "    ftol=1e-12,             # Termination by change in cost function.\n",
+    "    xtol=1e-9,             # Termination by change in parameters.\n",
+    "    gtol=1e-9,             # Termination by norm of the gradient.\n",
+    "\n",
+    "    # --- Scaling and Robustness ---\n",
+    "    x_scale='jac',         # Crucial for problems where parameters have very different\n",
+    "                           # magnitudes. Let the Jacobian estimate the scales.\n",
+    "    loss='linear',         # Standard least-squares. Change to 'soft_l1' if you\n",
+    "                           # suspect outliers in your data.\n",
+    "\n",
+    "    # --- Number of function evaluations ---\n",
+    "    max_nfev=100,\n",
+    "\n",
+    "    # --- Verbosity ---\n",
+    "    verbose=2              # Keep this at 2 to see the step-by-step progress\n",
+    "                           # of the optimization.\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3a10f7f1-4d41-4f27-ac56-46c6afd61660",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameestimatestdlow_95high_95guessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE16.2811482.38275811.59260420.96969216.180000False14.00000018.000000NaNNaN
dH_EdH_E-10715.921325767.697642-12226.516909-9205.325741-11000.000000False-15000.000000-5000.000000NaNNaN
nuisance_dil_CTnuisance_dil_CT-185.38803547.023238-277.915473-92.8605970.000000False-5000.0000005000.000000NaNNaN
nuisance_dil_ETnuisance_dil_ET-0.51149910.975166-22.10729021.0842920.000000False-5000.0000005000.000000NaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_2_CT_fudgenuisance_expt_2_CT_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_3_CT_fudgenuisance_expt_3_CT_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge1.100000NaNNaNNaN1.100000True0.8000001.200000NaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name      estimate        std  \\\n",
+       "name                                                                          \n",
+       "KE                                              KE     16.281148   2.382758   \n",
+       "dH_E                                          dH_E -10715.921325 767.697642   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT   -185.388035  47.023238   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET     -0.511499  10.975166   \n",
+       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_2_CT_fudge  nuisance_expt_2_CT_fudge      1.100000        NaN   \n",
+       "nuisance_expt_3_CT_fudge  nuisance_expt_3_CT_fudge      1.100000        NaN   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge      1.100000        NaN   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge      1.100000        NaN   \n",
+       "\n",
+       "                                low_95      high_95         guess  fixed  \\\n",
+       "name                                                                       \n",
+       "KE                           11.592604    20.969692     16.180000  False   \n",
+       "dH_E                     -12226.516909 -9205.325741 -11000.000000  False   \n",
+       "nuisance_dil_CT            -277.915473   -92.860597      0.000000  False   \n",
+       "nuisance_dil_ET             -22.107290    21.084292      0.000000  False   \n",
+       "nuisance_expt_0_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_1_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_2_CT_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_3_CT_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_4_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_5_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_6_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_7_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_8_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "nuisance_expt_9_ET_fudge           NaN          NaN      1.100000   True   \n",
+       "\n",
+       "                           lower_bound  upper_bound  prior_mean  prior_std  \n",
+       "name                                                                        \n",
+       "KE                           14.000000    18.000000         NaN        NaN  \n",
+       "dH_E                     -15000.000000 -5000.000000         NaN        NaN  \n",
+       "nuisance_dil_CT           -5000.000000  5000.000000         NaN        NaN  \n",
+       "nuisance_dil_ET           -5000.000000  5000.000000         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_2_CT_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_3_CT_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge      0.800000     1.200000         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge      0.800000     1.200000         NaN        NaN  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.set_option('display.float_format', lambda x: '%.6f' % x)\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd7e7f25-2292-4a3d-a51c-5b7a3a0801d6",
+   "metadata": {},
+   "source": [
+    "## f.fit_quality"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1987676f-1c6a-44a3-995e-44af42226172",
+   "metadata": {},
+   "source": [
+    "#### Plot results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'heat')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "style = {\"s\":50,\n",
+    "         \"facecolor\":\"none\",\n",
+    "         \"edgecolor\":\"black\"}\n",
+    "err_style = {\"lw\":0,\n",
+    "             \"elinewidth\":1,\n",
+    "             \"capsize\":2}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "edtaca_length = len(edtaca_list)\n",
+    "blank_length = len(blank_list)\n",
+    "\n",
+    "color_order = green_list[0:blank_length] + orange_list[0:edtaca_length]\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
+    "\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    \n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    err_style[\"color\"] = color_order[i]\n",
+    "\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values,y_values,**style)\n",
+    "    ax.errorbar(x=x_values,\n",
+    "                y=y_values,\n",
+    "                #yerr=y_err,\n",
+    "                **err_style)\n",
+    "\n",
+    "    ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n",
+    "\n",
+    "ax.set_ylim((-100,10))\n",
+    "\n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "327fc64a-a64e-4c18-9727-b2b2a90c5cc3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Plot settings\n",
+    "style = {\"s\": 50, \"facecolor\": \"none\"}\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "# Get fitted parameters and calculate theoretical heats\n",
+    "params = np.array(f.fit_df[\"estimate\"])\n",
+    "y_calc = gm.model(params)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, figsize=(8,6))\n",
+    "\n",
+    "# Get overall y range from experimental data to set limits\n",
+    "y_min = gm.as_df[\"y_obs\"].min()\n",
+    "y_max = gm.as_df[\"y_obs\"].max()\n",
+    "y_range = y_max - y_min\n",
+    "y_limits = [y_min - 15*y_range, y_max + 15*y_range]\n",
+    "\n",
+    "# Plot each experiment\n",
+    "for i in np.unique(gm.as_df.expt_id):\n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    \n",
+    "    # Get data for this experiment using gm.as_df\n",
+    "    mask = gm.as_df.expt_id == i\n",
+    "    this_df = gm.as_df.loc[mask,:]\n",
+    "    \n",
+    "    # Get theoretical heats for this experiment\n",
+    "    heats = y_calc[mask]\n",
+    "    # Calculate injection-to-injection differences\n",
+    "    heat_diffs = np.diff(heats, prepend=heats[0])\n",
+    "    \n",
+    "    # Get experimental points\n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = this_df[\"y_obs\"]\n",
+    "    \n",
+    "    # Plot experimental points\n",
+    "    ax.scatter(x_values, y_values, \n",
+    "              **style,\n",
+    "              label=f'Expt {i} (data)')\n",
+    "    \n",
+    "    # Plot theoretical curve using differences\n",
+    "    ax.plot(x_values, heat_diffs, '-',\n",
+    "            color=color_order[i],\n",
+    "            label=f'Expt {i} (fit)')\n",
+    "\n",
+    "ax.set_xlabel('Cumulative Injection')\n",
+    "ax.set_ylabel('Heat per injection (μcal)')\n",
+    "ax.set_ylim(y_limits)\n",
+    "ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d72d8bfd-d925-445e-967d-4f6603621a2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_corner(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_summary(f)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/global-fit-6state-workbook.ipynb b/notebooks/global-fit-6state-workbook.ipynb
new file mode 100644
index 0000000..310849c
--- /dev/null
+++ b/notebooks/global-fit-6state-workbook.ipynb
@@ -0,0 +1,1539 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b11cea11-6bb7-4286-9550-6a47f3c017ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import dataprob\n",
+    "import copy\n",
+    "import linkage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "75839bf7-0265-4c1b-9bdb-770c1d2fb2f1",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "### Load Experimental Data\n",
+    "cell_vol = 201.3\n",
+    "std_dev = 0.01\n",
+    "\n",
+    "## EDTA --> Protein + Ca\n",
+    "prot1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4HIGHRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "\n",
+    "prot2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto50uMhA4SUPERDUPERRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "\n",
+    "prot3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240823\\3mMEDTAto50uMhA4.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "\n",
+    "prot4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA4.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "prot5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA42.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot5.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "prot6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240822\\3mMEDTAto50uMhA43.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "prot6.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "## EDTA --> Buffer\n",
+    "\n",
+    "blank1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa2.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "blank1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "blank2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa3.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "blank2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "## Ca --> Buffer\n",
+    "\n",
+    "blank3 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "blank3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "blank4 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer2.csv\",\n",
+    "                                        cell_contents={},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "blank4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "## Ca --> EDTA\n",
+    "\n",
+    "caedta1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\500uMCato50uMEDTA.csv\",\n",
+    "                                      cell_contents={\"ET\":50e-6},\n",
+    "                                      syringe_contents={\"CT\":500e-6},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "caedta1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "## EDTA --> Ca\n",
+    "\n",
+    "edtaca1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3mMEDTAto500uMCa.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "\n",
+    "edtaca2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3p5mMEDTAto500uMCaCl2HHR.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "\n",
+    "edtaca3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240915\\3p5mMEDTAto500uMCaCl2lowres.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "\n",
+    "edtaca4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto500uMCaLOWRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "edtaca5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca5.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "edtaca6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca6.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "edtaca7 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_3.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca7.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=std_dev)\n",
+    "\n",
+    "## CD Experiments\n",
+    "\n",
+    "# cd1 = linkage.experiment.Experiment(r\"\",\n",
+    "#                                       cell_contents={\"CT\":500e-6, \"AT\":25e-6},\n",
+    "#                                       syringe_contents={\"ET\":2e-3},\n",
+    "#                                       cell_volume=cell_vol,\n",
+    "#                                       conc_to_float=\"ET\")\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1968e818-5032-4a5f-b34e-74251dc4a6dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#### Create model instance\n",
+    "#blank_list = [blank1, blank2]\n",
+    "#edtaca_list = [edtaca1, edtaca2, edtaca3, edtaca4, edtaca5, edtaca6, edtaca7, caedta1]\n",
+    "prot_list = [prot1, prot2, prot3, prot4, prot5, prot6]\n",
+    "\n",
+    "#Combine experiment types into one list\n",
+    "#expt_list = blank_list + edtaca_list + prot_list\n",
+    "\n",
+    "gm = linkage.GlobalModel(model_name=\"SixStateEDTA\",\n",
+    "                         expt_list=prot_list)\n",
+    "\n",
+    "f = dataprob.setup(gm.model_normalized,\n",
+    "                   vector_first_arg=True,\n",
+    "                   method=\"ml\",\n",
+    "                   fit_parameters=gm.parameter_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "10064dc1-cb03-4ea7-b107-2dba82d6ba2f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KIKI0.0False-infinfNaNNaN
KEKE0.0False-infinfNaNNaN
K1K10.0False-infinfNaNNaN
K2K20.0False-infinfNaNNaN
K3K30.0False-infinfNaNNaN
K4K40.0False-infinfNaNNaN
dH_IdH_I0.0False-infinfNaNNaN
dH_EdH_E0.0False-infinfNaNNaN
dH_1dH_10.0False-infinfNaNNaN
dH_2dH_20.0False-infinfNaNNaN
dH_3dH_30.0False-infinfNaNNaN
dH_4dH_40.0False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ET0.0False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge0.0False-infinfNaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge0.0False-infinfNaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name  guess  fixed  lower_bound  \\\n",
+       "name                                                                            \n",
+       "KI                                              KI    0.0  False         -inf   \n",
+       "KE                                              KE    0.0  False         -inf   \n",
+       "K1                                              K1    0.0  False         -inf   \n",
+       "K2                                              K2    0.0  False         -inf   \n",
+       "K3                                              K3    0.0  False         -inf   \n",
+       "K4                                              K4    0.0  False         -inf   \n",
+       "dH_I                                          dH_I    0.0  False         -inf   \n",
+       "dH_E                                          dH_E    0.0  False         -inf   \n",
+       "dH_1                                          dH_1    0.0  False         -inf   \n",
+       "dH_2                                          dH_2    0.0  False         -inf   \n",
+       "dH_3                                          dH_3    0.0  False         -inf   \n",
+       "dH_4                                          dH_4    0.0  False         -inf   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET    0.0  False         -inf   \n",
+       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge    0.0  False         -inf   \n",
+       "\n",
+       "                          upper_bound  prior_mean  prior_std  \n",
+       "name                                                          \n",
+       "KI                                inf         NaN        NaN  \n",
+       "KE                                inf         NaN        NaN  \n",
+       "K1                                inf         NaN        NaN  \n",
+       "K2                                inf         NaN        NaN  \n",
+       "K3                                inf         NaN        NaN  \n",
+       "K4                                inf         NaN        NaN  \n",
+       "dH_I                              inf         NaN        NaN  \n",
+       "dH_E                              inf         NaN        NaN  \n",
+       "dH_1                              inf         NaN        NaN  \n",
+       "dH_2                              inf         NaN        NaN  \n",
+       "dH_3                              inf         NaN        NaN  \n",
+       "dH_4                              inf         NaN        NaN  \n",
+       "nuisance_dil_ET                   inf         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge          inf         NaN        NaN  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "## Show empty parameter df\n",
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4ac7eaa7-d428-497a-8bb9-1e6d36580023",
+   "metadata": {
+    "editable": true,
+    "scrolled": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "## Assign parameter attributes\n",
+    "\n",
+    "#Equilibrium Constant Guesses\n",
+    "f.param_df.loc[\"KI\",\"guess\"] = -4.6\n",
+    "f.param_df.loc[\"KI\",\"upper_bound\"] = -2\n",
+    "f.param_df.loc[\"KI\",\"lower_bound\"] = -10\n",
+    "f.param_df.loc[\"KI\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"KE\",\"guess\"] = 16.4\n",
+    "f.param_df.loc[\"KE\",\"upper_bound\"] = 18.5\n",
+    "f.param_df.loc[\"KE\",\"lower_bound\"] = 15.0\n",
+    "f.param_df.loc[\"KE\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"K1\",\"guess\"] = 7\n",
+    "f.param_df.loc[\"K1\",\"upper_bound\"] = 7.93\n",
+    "f.param_df.loc[\"K1\",\"lower_bound\"] = 6.14\n",
+    "f.param_df.loc[\"K1\",\"fixed\"] = False\n",
+    "\n",
+    "f.param_df.loc[\"K2\",\"guess\"] = 12.7\n",
+    "f.param_df.loc[\"K2\",\"upper_bound\"] = 13.48\n",
+    "f.param_df.loc[\"K2\",\"lower_bound\"] = 11.95\n",
+    "f.param_df.loc[\"K2\",\"fixed\"] = False\n",
+    "\n",
+    "f.param_df.loc[\"K3\",\"guess\"] = 7\n",
+    "f.param_df.loc[\"K3\",\"upper_bound\"] = 10\n",
+    "f.param_df.loc[\"K3\",\"lower_bound\"] = 2\n",
+    "f.param_df.loc[\"K3\",\"fixed\"] = False\n",
+    "\n",
+    "f.param_df.loc[\"K4\",\"guess\"] = 7\n",
+    "f.param_df.loc[\"K4\",\"upper_bound\"] = 10\n",
+    "f.param_df.loc[\"K4\",\"lower_bound\"] = 2\n",
+    "f.param_df.loc[\"K4\", \"fixed\"] = False\n",
+    "\n",
+    "\n",
+    "# ### Nuisance Param Guesses\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"guess\"] = -149\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"upper_bound\"] = -148\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"lower_bound\"] = -150\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"guess\"] = -6.1\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"upper_bound\"] = -6.0\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"lower_bound\"] = -6.2\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"fixed\"] = True\n",
+    "\n",
+    "\n",
+    "# Get all parameter names containing 'nuisance_expt' and 'ET_fudge'\n",
+    "fudge_params = [col for col in f.param_df.index if 'nuisance_expt' in col]\n",
+    "\n",
+    "# Link all fudge parameters (except 0) to the first one\n",
+    "for param in fudge_params:\n",
+    "        f.param_df.loc[param, 'guess'] = 1.05\n",
+    "        f.param_df.loc[param, 'fixed'] = True\n",
+    "        f.param_df.loc[param, 'lower_bound'] = -2\n",
+    "        f.param_df.loc[param, 'upper_bound'] = 2\n",
+    "\n",
+    "# # ### Enthalpy Guesses\n",
+    "\n",
+    "f.param_df.loc[\"dH_I\",\"guess\"] = 0\n",
+    "f.param_df.loc[\"dH_I\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"dH_E\",\"guess\"] = -10852\n",
+    "f.param_df.loc[\"dH_E\",\"upper_bound\"] = -10800\n",
+    "f.param_df.loc[\"dH_E\",\"lower_bound\"] = -10900\n",
+    "f.param_df.loc[\"dH_E\",\"fixed\"] = True\n",
+    "\n",
+    "f.param_df.loc[\"dH_1\",\"guess\"] = 100\n",
+    "f.param_df.loc[\"dH_1\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_1\",\"lower_bound\"] = 0\n",
+    "\n",
+    "f.param_df.loc[\"dH_2\",\"guess\"] = 100\n",
+    "f.param_df.loc[\"dH_2\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_2\",\"lower_bound\"] = 0\n",
+    "\n",
+    "f.param_df.loc[\"dH_3\",\"guess\"] = 100\n",
+    "f.param_df.loc[\"dH_3\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_3\",\"lower_bound\"] = 0\n",
+    "\n",
+    "f.param_df.loc[\"dH_4\",\"guess\"] = 100\n",
+    "f.param_df.loc[\"dH_4\",\"upper_bound\"] = 10000\n",
+    "f.param_df.loc[\"dH_4\",\"lower_bound\"] = 0\n",
+    "\n",
+    "\n",
+    "# f.param_df.loc[\"\",\"parent\"] = ''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "78a99977-82b8-41ff-98e4-6909d60696f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameguessfixedlower_boundupper_boundprior_meanprior_std
name
KIKI-4.60True-10.00-2.00NaNNaN
KEKE16.40True15.0018.50NaNNaN
K1K17.00False6.147.93NaNNaN
K2K212.70False11.9513.48NaNNaN
K3K37.00False2.0010.00NaNNaN
K4K47.00False2.0010.00NaNNaN
dH_IdH_I0.00True-infinfNaNNaN
dH_EdH_E-10852.00True-10900.00-10800.00NaNNaN
dH_1dH_1100.00False0.0010000.00NaNNaN
dH_2dH_2100.00False0.0010000.00NaNNaN
dH_3dH_3100.00False0.0010000.00NaNNaN
dH_4dH_4100.00False0.0010000.00NaNNaN
nuisance_dil_ETnuisance_dil_ET-6.10True-6.20-6.00NaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.05True-2.002.00NaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.05True-2.002.00NaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge1.05True-2.002.00NaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge1.05True-2.002.00NaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.05True-2.002.00NaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.05True-2.002.00NaNNaN
nuisance_dil_CTNaN-149.00True-150.00-148.00NaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name     guess  fixed  \\\n",
+       "name                                                                  \n",
+       "KI                                              KI     -4.60   True   \n",
+       "KE                                              KE     16.40   True   \n",
+       "K1                                              K1      7.00  False   \n",
+       "K2                                              K2     12.70  False   \n",
+       "K3                                              K3      7.00  False   \n",
+       "K4                                              K4      7.00  False   \n",
+       "dH_I                                          dH_I      0.00   True   \n",
+       "dH_E                                          dH_E -10852.00   True   \n",
+       "dH_1                                          dH_1    100.00  False   \n",
+       "dH_2                                          dH_2    100.00  False   \n",
+       "dH_3                                          dH_3    100.00  False   \n",
+       "dH_4                                          dH_4    100.00  False   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET     -6.10   True   \n",
+       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge      1.05   True   \n",
+       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge      1.05   True   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge      1.05   True   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge      1.05   True   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.05   True   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.05   True   \n",
+       "nuisance_dil_CT                                NaN   -149.00   True   \n",
+       "\n",
+       "                          lower_bound  upper_bound  prior_mean  prior_std  \n",
+       "name                                                                       \n",
+       "KI                             -10.00        -2.00         NaN        NaN  \n",
+       "KE                              15.00        18.50         NaN        NaN  \n",
+       "K1                               6.14         7.93         NaN        NaN  \n",
+       "K2                              11.95        13.48         NaN        NaN  \n",
+       "K3                               2.00        10.00         NaN        NaN  \n",
+       "K4                               2.00        10.00         NaN        NaN  \n",
+       "dH_I                             -inf          inf         NaN        NaN  \n",
+       "dH_E                        -10900.00    -10800.00         NaN        NaN  \n",
+       "dH_1                             0.00     10000.00         NaN        NaN  \n",
+       "dH_2                             0.00     10000.00         NaN        NaN  \n",
+       "dH_3                             0.00     10000.00         NaN        NaN  \n",
+       "dH_4                             0.00     10000.00         NaN        NaN  \n",
+       "nuisance_dil_ET                 -6.20        -6.00         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge        -2.00         2.00         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge        -2.00         2.00         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge        -2.00         2.00         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge        -2.00         2.00         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge        -2.00         2.00         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge        -2.00         2.00         NaN        NaN  \n",
+       "nuisance_dil_CT               -150.00      -148.00         NaN        NaN  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "## Check parameter assignments\n",
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9dce9812-ebe1-49f2-ae1e-61f4a14b8ff5",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "\nValues in the 'name' column in a parameter dataframe must\nbe identical to the fit parameter names.\n\nExtra values:\n    nan\n\n",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[7], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Run fit\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m      4\u001b[0m \u001b[43m      \u001b[49m\u001b[43my_obs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43my_obs_normalized\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m      5\u001b[0m \u001b[43m      \u001b[49m\u001b[43my_std\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43my_std_normalized\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m      6\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m#max_convergence_cycles=1,\u001b[39;49;00m\n\u001b[0;32m      7\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m#use_ml_guess=False,\u001b[39;49;00m\n\u001b[0;32m      8\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m#num_steps=800,\u001b[39;49;00m\n\u001b[0;32m      9\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m#num_walkers=200, # number of markov chains to use in the analysis, default=100       \u001b[39;49;00m\n\u001b[0;32m     10\u001b[0m \u001b[43m      \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtrf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Algorithm to use for optimization\u001b[39;49;00m\n\u001b[0;32m     11\u001b[0m \u001b[43m      \u001b[49m\u001b[43mjac\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m3-point\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Method for computing the Jacobian matrix\u001b[39;49;00m\n\u001b[0;32m     12\u001b[0m \u001b[43m      \u001b[49m\u001b[43mftol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1e-15\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Tolerance for termination by the change of the cost function\u001b[39;49;00m\n\u001b[0;32m     13\u001b[0m \u001b[43m      \u001b[49m\u001b[43mxtol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1e-12\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Tolerance for termination by the change of the independent variables\u001b[39;49;00m\n\u001b[0;32m     14\u001b[0m \u001b[43m      \u001b[49m\u001b[43mgtol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1e-12\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Tolerance for termination by the norm of the gradient\u001b[39;49;00m\n\u001b[0;32m     15\u001b[0m \u001b[43m      \u001b[49m\u001b[43mx_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mjac\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Scaling of the variables\u001b[39;49;00m\n\u001b[0;32m     16\u001b[0m \u001b[43m      \u001b[49m\u001b[43mloss\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlinear\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Loss function for dealing with outliers\u001b[39;49;00m\n\u001b[0;32m     17\u001b[0m \u001b[43m      \u001b[49m\u001b[43mf_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Soft margin between inlier and outlier residuals\u001b[39;49;00m\n\u001b[0;32m     18\u001b[0m \u001b[43m      \u001b[49m\u001b[43mmax_nfev\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m25\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Maximum number of function evaluations\u001b[39;49;00m\n\u001b[0;32m     19\u001b[0m \u001b[43m      \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Level of algorithm's verbosity\u001b[39;49;00m\n\u001b[0;32m     20\u001b[0m \u001b[43m     \u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\ml.py:52\u001b[0m, in \u001b[0;36mMLFitter.fit\u001b[1;34m(self, y_obs, y_std, num_samples, **least_squares_kwargs)\u001b[0m\n\u001b[0;32m     28\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m     29\u001b[0m \u001b[38;5;124;03mFit the model parameters to the data by maximum likelihood.\u001b[39;00m\n\u001b[0;32m     30\u001b[0m \n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     45\u001b[0m \u001b[38;5;124;03m    scipy.optimize.least_squares\u001b[39;00m\n\u001b[0;32m     46\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m     48\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_samples \u001b[38;5;241m=\u001b[39m check_int(value\u001b[38;5;241m=\u001b[39mnum_samples,\n\u001b[0;32m     49\u001b[0m                               variable_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnum_samples\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m     50\u001b[0m                               minimum_allowed\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m---> 52\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_obs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_obs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     53\u001b[0m \u001b[43m            \u001b[49m\u001b[43my_std\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_std\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     54\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mleast_squares_kwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\fitters\\base.py:170\u001b[0m, in \u001b[0;36mFitter.fit\u001b[1;34m(self, y_obs, y_std, **kwargs)\u001b[0m\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_success \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m    169\u001b[0m \u001b[38;5;66;03m# Finalize model\u001b[39;00m\n\u001b[1;32m--> 170\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfinalize_params\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    172\u001b[0m \u001b[38;5;66;03m# Run the fit\u001b[39;00m\n\u001b[0;32m    173\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\model_wrapper\\vector_model_wrapper.py:161\u001b[0m, in \u001b[0;36mVectorModelWrapper.finalize_params\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    153\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    154\u001b[0m \u001b[38;5;124;03mValidate current state of param_df and build map between parameters\u001b[39;00m\n\u001b[0;32m    155\u001b[0m \u001b[38;5;124;03mand the model arguments. This will be called by a Fitter instance \u001b[39;00m\n\u001b[0;32m    156\u001b[0m \u001b[38;5;124;03mbefore doing a fit. \u001b[39;00m\n\u001b[0;32m    157\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    159\u001b[0m \u001b[38;5;66;03m# Make sure the parameter dataframe is sane. It could have problems \u001b[39;00m\n\u001b[0;32m    160\u001b[0m \u001b[38;5;66;03m# because we let the user edit it directly.\u001b[39;00m\n\u001b[1;32m--> 161\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_param_df \u001b[38;5;241m=\u001b[39m \u001b[43mvalidate_dataframe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparam_df\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_param_df\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    162\u001b[0m \u001b[43m                                    \u001b[49m\u001b[43mparam_in_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit_params_in_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    163\u001b[0m \u001b[43m                                    \u001b[49m\u001b[43mdefault_guess\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_default_guess\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    165\u001b[0m \u001b[38;5;66;03m# Get currently un-fixed parameters\u001b[39;00m\n\u001b[0;32m    166\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_unfixed_mask \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(np\u001b[38;5;241m.\u001b[39mlogical_not(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_param_df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfixed\u001b[39m\u001b[38;5;124m\"\u001b[39m]),dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mbool\u001b[39m)\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\model_wrapper\\_dataframe_processing.py:290\u001b[0m, in \u001b[0;36mvalidate_dataframe\u001b[1;34m(param_df, param_in_order, default_guess)\u001b[0m\n\u001b[0;32m    287\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(err)\n\u001b[0;32m    289\u001b[0m \u001b[38;5;66;03m# Check dataframe entries\u001b[39;00m\n\u001b[1;32m--> 290\u001b[0m param_df \u001b[38;5;241m=\u001b[39m \u001b[43m_check_name\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparam_df\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparam_df\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    291\u001b[0m \u001b[43m                       \u001b[49m\u001b[43mparam_in_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparam_in_order\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    293\u001b[0m param_df \u001b[38;5;241m=\u001b[39m _build_columns(param_df\u001b[38;5;241m=\u001b[39mparam_df,\n\u001b[0;32m    294\u001b[0m                           default_guess\u001b[38;5;241m=\u001b[39mdefault_guess)\n\u001b[0;32m    296\u001b[0m param_df \u001b[38;5;241m=\u001b[39m _check_bounds(param_df\u001b[38;5;241m=\u001b[39mparam_df)\n",
+      "File \u001b[1;32m~\\dataprob\\src\\dataprob\\model_wrapper\\_dataframe_processing.py:49\u001b[0m, in \u001b[0;36m_check_name\u001b[1;34m(param_df, param_in_order)\u001b[0m\n\u001b[0;32m     46\u001b[0m             err \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m    \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mv\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m     47\u001b[0m         err \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m---> 49\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(err)\n\u001b[0;32m     51\u001b[0m \u001b[38;5;66;03m# Make sure the index is the parameter name\u001b[39;00m\n\u001b[0;32m     52\u001b[0m param_df\u001b[38;5;241m.\u001b[39mindex \u001b[38;5;241m=\u001b[39m param_df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n",
+      "\u001b[1;31mValueError\u001b[0m: \nValues in the 'name' column in a parameter dataframe must\nbe identical to the fit parameter names.\n\nExtra values:\n    nan\n\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run fit\n",
+    "\n",
+    "f.fit(\n",
+    "      y_obs=gm.y_obs_normalized,\n",
+    "      y_std=gm.y_std_normalized,\n",
+    "      #max_convergence_cycles=1,\n",
+    "      #use_ml_guess=False,\n",
+    "      #num_steps=800,\n",
+    "      #num_walkers=200, # number of markov chains to use in the analysis, default=100       \n",
+    "      method='trf',  # Algorithm to use for optimization\n",
+    "      jac='3-point',  # Method for computing the Jacobian matrix\n",
+    "      ftol=1e-15,  # Tolerance for termination by the change of the cost function\n",
+    "      xtol=1e-12,  # Tolerance for termination by the change of the independent variables\n",
+    "      gtol=1e-12,  # Tolerance for termination by the norm of the gradient\n",
+    "      x_scale='jac',  # Scaling of the variables\n",
+    "      loss='linear',  # Loss function for dealing with outliers\n",
+    "      f_scale=0.1,  # Soft margin between inlier and outlier residuals\n",
+    "      max_nfev=25,  # Maximum number of function evaluations\n",
+    "      verbose=2  # Level of algorithm's verbosity\n",
+    "     )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a10f7f1-4d41-4f27-ac56-46c6afd61660",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pd.set_option('display.float_format', lambda x: '%.6f' % x)\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd7e7f25-2292-4a3d-a51c-5b7a3a0801d6",
+   "metadata": {},
+   "source": [
+    "## f.fit_quality"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1987676f-1c6a-44a3-995e-44af42226172",
+   "metadata": {},
+   "source": [
+    "#### Plot results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameestimatestdlow_95high_95guessfixedlower_boundupper_boundprior_meanprior_std
name
KIKI-4.600000NaNNaNNaN-4.600000True-10.000000-2.000000NaNNaN
KEKE18.200000NaNNaNNaN18.200000True18.00000018.500000NaNNaN
K1K16.1400001.0676044.0347318.2452697.000000False6.1400007.930000NaNNaN
K2K211.9500001.1287649.72412614.17587412.700000False11.95000013.480000NaNNaN
K3K39.3804580.1083139.1668709.5940467.000000False2.00000010.000000NaNNaN
K4K410.0000000.0434389.91434210.0856587.000000False2.00000010.000000NaNNaN
dH_IdH_I0.000000NaNNaNNaN0.000000True-infinfNaNNaN
dH_EdH_E-10852.000000NaNNaNNaN-10852.000000True-10900.000000-10800.000000NaNNaN
dH_1dH_10.000000804.031346-1585.5148751585.514875100.000000False0.00000010000.000000NaNNaN
dH_2dH_20.000000402.814032-794.331767794.331767100.000000False0.00000010000.000000NaNNaN
dH_3dH_310000.000000778.2607208465.30368011534.696320100.000000False0.00000010000.000000NaNNaN
dH_4dH_410000.00000025.7604939949.20142810050.798572100.000000False0.00000010000.000000NaNNaN
nuisance_dil_ETnuisance_dil_ET-6.100000NaNNaNNaN-6.100000True-6.200000-6.000000NaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.050000NaNNaNNaN1.050000True-2.0000002.000000NaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.050000NaNNaNNaN1.050000True-2.0000002.000000NaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge1.050000NaNNaNNaN1.050000True-2.0000002.000000NaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge1.050000NaNNaNNaN1.050000True-2.0000002.000000NaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.050000NaNNaNNaN1.050000True-2.0000002.000000NaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.050000NaNNaNNaN1.050000True-2.0000002.000000NaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name      estimate        std  \\\n",
+       "name                                                                          \n",
+       "KI                                              KI     -4.600000        NaN   \n",
+       "KE                                              KE     18.200000        NaN   \n",
+       "K1                                              K1      6.140000   1.067604   \n",
+       "K2                                              K2     11.950000   1.128764   \n",
+       "K3                                              K3      9.380458   0.108313   \n",
+       "K4                                              K4     10.000000   0.043438   \n",
+       "dH_I                                          dH_I      0.000000        NaN   \n",
+       "dH_E                                          dH_E -10852.000000        NaN   \n",
+       "dH_1                                          dH_1      0.000000 804.031346   \n",
+       "dH_2                                          dH_2      0.000000 402.814032   \n",
+       "dH_3                                          dH_3  10000.000000 778.260720   \n",
+       "dH_4                                          dH_4  10000.000000  25.760493   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET     -6.100000        NaN   \n",
+       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge      1.050000        NaN   \n",
+       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge      1.050000        NaN   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge      1.050000        NaN   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge      1.050000        NaN   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.050000        NaN   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.050000        NaN   \n",
+       "\n",
+       "                               low_95      high_95         guess  fixed  \\\n",
+       "name                                                                      \n",
+       "KI                                NaN          NaN     -4.600000   True   \n",
+       "KE                                NaN          NaN     18.200000   True   \n",
+       "K1                           4.034731     8.245269      7.000000  False   \n",
+       "K2                           9.724126    14.175874     12.700000  False   \n",
+       "K3                           9.166870     9.594046      7.000000  False   \n",
+       "K4                           9.914342    10.085658      7.000000  False   \n",
+       "dH_I                              NaN          NaN      0.000000   True   \n",
+       "dH_E                              NaN          NaN -10852.000000   True   \n",
+       "dH_1                     -1585.514875  1585.514875    100.000000  False   \n",
+       "dH_2                      -794.331767   794.331767    100.000000  False   \n",
+       "dH_3                      8465.303680 11534.696320    100.000000  False   \n",
+       "dH_4                      9949.201428 10050.798572    100.000000  False   \n",
+       "nuisance_dil_ET                   NaN          NaN     -6.100000   True   \n",
+       "nuisance_expt_0_ET_fudge          NaN          NaN      1.050000   True   \n",
+       "nuisance_expt_1_ET_fudge          NaN          NaN      1.050000   True   \n",
+       "nuisance_expt_2_ET_fudge          NaN          NaN      1.050000   True   \n",
+       "nuisance_expt_3_ET_fudge          NaN          NaN      1.050000   True   \n",
+       "nuisance_expt_4_ET_fudge          NaN          NaN      1.050000   True   \n",
+       "nuisance_expt_5_ET_fudge          NaN          NaN      1.050000   True   \n",
+       "\n",
+       "                           lower_bound   upper_bound  prior_mean  prior_std  \n",
+       "name                                                                         \n",
+       "KI                          -10.000000     -2.000000         NaN        NaN  \n",
+       "KE                           18.000000     18.500000         NaN        NaN  \n",
+       "K1                            6.140000      7.930000         NaN        NaN  \n",
+       "K2                           11.950000     13.480000         NaN        NaN  \n",
+       "K3                            2.000000     10.000000         NaN        NaN  \n",
+       "K4                            2.000000     10.000000         NaN        NaN  \n",
+       "dH_I                              -inf           inf         NaN        NaN  \n",
+       "dH_E                     -10900.000000 -10800.000000         NaN        NaN  \n",
+       "dH_1                          0.000000  10000.000000         NaN        NaN  \n",
+       "dH_2                          0.000000  10000.000000         NaN        NaN  \n",
+       "dH_3                          0.000000  10000.000000         NaN        NaN  \n",
+       "dH_4                          0.000000  10000.000000         NaN        NaN  \n",
+       "nuisance_dil_ET              -6.200000     -6.000000         NaN        NaN  \n",
+       "nuisance_expt_0_ET_fudge     -2.000000      2.000000         NaN        NaN  \n",
+       "nuisance_expt_1_ET_fudge     -2.000000      2.000000         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge     -2.000000      2.000000         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge     -2.000000      2.000000         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge     -2.000000      2.000000         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge     -2.000000      2.000000         NaN        NaN  "
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "style = {\"s\":50,\n",
+    "         \"facecolor\":\"none\",\n",
+    "         \"edgecolor\":\"black\"}\n",
+    "err_style = {\"lw\":0,\n",
+    "             \"elinewidth\":1,\n",
+    "             \"capsize\":2}\n",
+    "\n",
+    "orange_list = ['#FFEEDD', '#FFD6AA', '#FFB366', '#FF9933', '#FF8000', '#FF6600', '#FF4400', '#CC3300', '#992200', '#FF0000'] \n",
+    "purple_list = ['#F2E6FF', '#E0B3FF', '#CC80FF', '#B84DFF', '#A31AFF', '#8800E6', '#6600B3', '#440080', '#2B0052', '#1A0033']\n",
+    "green_list = ['#E8FFE8', '#C1FFC1', '#9AFF9A', '#74FF74', '#4DFF4D', '#26FF26', '#00E600', '#00B300', '#008000', '#004D00']\n",
+    "\n",
+    "# edtaca_length = len(edtaca_list)\n",
+    "prot_length = len(prot_list)\n",
+    "# blank_length = len(blank_list)\n",
+    "\n",
+    "#color_order = green_list[0:blank_length] + orange_list[0:edtaca_length] + purple_list[0:prot_length]\n",
+    "color_order = purple_list[0:prot_length]\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
+    "\n",
+    "out_df = gm.as_df.copy()\n",
+    "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
+    "\n",
+    "for i in np.unique(out_df.expt_id):\n",
+    "    \n",
+    "    style[\"edgecolor\"] = color_order[i]\n",
+    "    err_style[\"color\"] = color_order[i]\n",
+    "\n",
+    "    mask = out_df[\"expt_id\"] == i\n",
+    "    this_df = out_df.loc[mask,:]\n",
+    "\n",
+    "    \n",
+    "    x_values = np.cumsum(this_df[\"injection\"])\n",
+    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
+    "\n",
+    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    \n",
+    "    ax.scatter(x_values,y_values,**style)\n",
+    "    ax.errorbar(x=x_values,\n",
+    "                y=y_values,\n",
+    "                yerr=y_err,\n",
+    "                **err_style)\n",
+    "\n",
+    "    ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n",
+    "    \n",
+    "\n",
+    "plt.xlabel(\"injection\")\n",
+    "plt.ylabel(\"heat\")\n",
+    "\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d72d8bfd-d925-445e-967d-4f6603621a2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_corner(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "fig = dataprob.plot_summary(f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81dc68e5-756e-4b53-8b09-704f935525e7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/global-fit.ipynb b/notebooks/global-fit.ipynb
index cfb0c94..567d651 100644
--- a/notebooks/global-fit.ipynb
+++ b/notebooks/global-fit.ipynb
@@ -11,11 +11,16 @@
     "from matplotlib import pyplot as plt\n",
     "import numpy as np\n",
     "import pandas as pd\n",
-    "\n",
     "import dataprob\n",
     "import copy\n",
-    "\n",
-    "import linkage\n"
+    "import linkage\n",
+    "import time\n",
+    "from scipy.stats import qmc\n",
+    "import warnings\n",
+    "import matplotlib.pyplot as mpl\n",
+    "from IPython.display import clear_output\n",
+    "import os\n",
+    "import logging"
    ]
   },
   {
@@ -33,22 +38,102 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "#### Load Experimental Data\n",
     "\n",
-    "blank = linkage.experiment.Experiment(\"data/itc_blank_expt.csv\",\n",
-    "                                      cell_contents={},\n",
-    "                                      syringe_contents={\"ET\":4e-3},\n",
-    "                                      cell_volume=201.3e-6,\n",
-    "                                      conc_to_float=\"ET\")\n",
-    "blank.define_itc_observable(obs_column=\"obs_heat\",\n",
-    "                            obs_std=1e-6)\n",
+    "## EDTA --> Buffer\n",
+    "\n",
+    "cell_vol = 201.3\n",
     "\n",
-    "binding = linkage.experiment.Experiment(\"data/itc_binding_expt.csv\",\n",
-    "                                        cell_contents={\"CT\":0.5e-3},\n",
-    "                                        syringe_contents={\"ET\":3e-3},\n",
-    "                                        cell_volume=201.3e-6,\n",
+    "## EDTA --> Buffer\n",
+    "\n",
+    "edtablank1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa2.csv\",\n",
+    "                                        cell_contents={\"CT\":0},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"ET\")\n",
+    "edtablank1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtablank2 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240806\\4mMEDTAinto0uMCa3.csv\",\n",
+    "                                        cell_contents={\"CT\":0},\n",
+    "                                        syringe_contents={\"ET\":4e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
     "                                        conc_to_float=\"ET\")\n",
-    "binding.define_itc_observable(obs_column=\"obs_heat\",\n",
-    "                              obs_std=1e-6)\n"
+    "edtablank2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## Ca --> Buffer\n",
+    "\n",
+    "cablank1 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer.csv\",\n",
+    "                                        cell_contents={\"ET\":0},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "cablank1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "cablank2 = linkage.experiment.Experiment(r\"S:\\Harmslab\\ITC2\\20241220\\1mMCatobuffer2.csv\",\n",
+    "                                        cell_contents={\"ET\":0},\n",
+    "                                        syringe_contents={\"CT\":1e-3},\n",
+    "                                        cell_volume=cell_vol,\n",
+    "                                        conc_to_float=\"CT\")\n",
+    "cablank2.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "## EDTA --> Ca\n",
+    "\n",
+    "edtaca1 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20241001\\3mMEDTAto500uMCa.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca1.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "edtaca3 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240915\\3p5mMEDTAto500uMCaCl2lowres.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca3.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "\n",
+    "edtaca4 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240913\\3p5mMEDTAto500uMCaLOWRES.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3.5e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca4.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtaca5 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca5.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtaca6 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_2.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca6.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "edtaca7 = linkage.experiment.Experiment(r\"C:\\Users\\willi\\linkage\\notebooks\\data\\20240912\\3mMEDTAto500uMCaCl2_3.csv\",\n",
+    "                                      cell_contents={\"CT\":500e-6},\n",
+    "                                      syringe_contents={\"ET\":3e-3},\n",
+    "                                      cell_volume=cell_vol,\n",
+    "                                      conc_to_float=\"ET\")\n",
+    "edtaca7.define_itc_observable(obs_column=\"heat\",\n",
+    "                            obs_std=\"heat_stdev\")\n",
+    "\n",
+    "#5/6 bad, WHY?\n",
+    "\n"
    ]
   },
   {
@@ -64,27 +149,6 @@
    "execution_count": 3,
    "id": "973ecc70-baf0-4fc2-a25a-047d67b0da51",
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "expt_list = [blank,binding] \n",
-    "\n",
-    "gm = linkage.GlobalModel(model_name=\"CaEDTA\",\n",
-    "                         expt_list=expt_list)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "293deeb5-170a-4b1d-9261-8366c78b2423",
-   "metadata": {},
-   "source": [
-    "#### Do fit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "4ac7eaa7-d428-497a-8bb9-1e6d36580023",
-   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -108,10 +172,6 @@
        "    \n",
        "      \n",
        "      name\n",
-       "      estimate\n",
-       "      std\n",
-       "      low_95\n",
-       "      high_95\n",
        "      guess\n",
        "      fixed\n",
        "      lower_bound\n",
@@ -128,34 +188,32 @@
        "      \n",
        "      \n",
        "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
        "    \n",
        "  \n",
        "  \n",
        "    \n",
        "      KE\n",
        "      KE\n",
-       "      17.268426\n",
-       "      0.260890\n",
-       "      16.746914\n",
-       "      17.789939\n",
-       "      17.0\n",
-       "      False\n",
        "      0.0\n",
-       "      25.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
        "    \n",
        "      dH_E\n",
        "      dH_E\n",
-       "      -11074.855329\n",
-       "      45.697703\n",
-       "      -11166.203736\n",
-       "      -10983.506923\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_dil_CT\n",
+       "      nuisance_dil_CT\n",
        "      0.0\n",
        "      False\n",
        "      -inf\n",
@@ -166,10 +224,6 @@
        "    \n",
        "      nuisance_dil_ET\n",
        "      nuisance_dil_ET\n",
-       "      -1.777205\n",
-       "      32.914516\n",
-       "      -67.572385\n",
-       "      64.017976\n",
        "      0.0\n",
        "      False\n",
        "      -inf\n",
@@ -178,28 +232,100 @@
        "      NaN\n",
        "    \n",
        "    \n",
-       "      nuisance_expt_0_ET_fudge\n",
-       "      nuisance_expt_0_ET_fudge\n",
-       "      1.100000\n",
+       "      nuisance_expt_0_CT_fudge\n",
+       "      nuisance_expt_0_CT_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
        "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_1_CT_fudge\n",
+       "      nuisance_expt_1_CT_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
        "      NaN\n",
        "      NaN\n",
-       "      1.1\n",
-       "      True\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_2_ET_fudge\n",
+       "      nuisance_expt_2_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
        "      -inf\n",
        "      inf\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
        "    \n",
-       "      nuisance_expt_1_ET_fudge\n",
-       "      nuisance_expt_1_ET_fudge\n",
-       "      1.100000\n",
+       "      nuisance_expt_3_ET_fudge\n",
+       "      nuisance_expt_3_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
        "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_4_ET_fudge\n",
+       "      nuisance_expt_4_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
        "      NaN\n",
        "      NaN\n",
-       "      1.1\n",
-       "      True\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_5_ET_fudge\n",
+       "      nuisance_expt_5_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_6_ET_fudge\n",
+       "      nuisance_expt_6_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_7_ET_fudge\n",
+       "      nuisance_expt_7_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_8_ET_fudge\n",
+       "      nuisance_expt_8_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
+       "      -inf\n",
+       "      inf\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_9_ET_fudge\n",
+       "      nuisance_expt_9_ET_fudge\n",
+       "      0.0\n",
+       "      False\n",
        "      -inf\n",
        "      inf\n",
        "      NaN\n",
@@ -210,61 +336,111 @@
        ""
       ],
       "text/plain": [
-       "                                              name      estimate        std  \\\n",
-       "name                                                                          \n",
-       "KE                                              KE     17.268426   0.260890   \n",
-       "dH_E                                          dH_E -11074.855329  45.697703   \n",
-       "nuisance_dil_ET                    nuisance_dil_ET     -1.777205  32.914516   \n",
-       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge      1.100000        NaN   \n",
-       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge      1.100000        NaN   \n",
+       "                                              name  guess  fixed  lower_bound  \\\n",
+       "name                                                                            \n",
+       "KE                                              KE    0.0  False         -inf   \n",
+       "dH_E                                          dH_E    0.0  False         -inf   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT    0.0  False         -inf   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET    0.0  False         -inf   \n",
+       "nuisance_expt_0_CT_fudge  nuisance_expt_0_CT_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_1_CT_fudge  nuisance_expt_1_CT_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge    0.0  False         -inf   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge    0.0  False         -inf   \n",
        "\n",
-       "                                low_95       high_95  guess  fixed  \\\n",
-       "name                                                                 \n",
-       "KE                           16.746914     17.789939   17.0  False   \n",
-       "dH_E                     -11166.203736 -10983.506923    0.0  False   \n",
-       "nuisance_dil_ET             -67.572385     64.017976    0.0  False   \n",
-       "nuisance_expt_0_ET_fudge           NaN           NaN    1.1   True   \n",
-       "nuisance_expt_1_ET_fudge           NaN           NaN    1.1   True   \n",
-       "\n",
-       "                          lower_bound  upper_bound  prior_mean  prior_std  \n",
-       "name                                                                       \n",
-       "KE                                0.0         25.0         NaN        NaN  \n",
-       "dH_E                             -inf          inf         NaN        NaN  \n",
-       "nuisance_dil_ET                  -inf          inf         NaN        NaN  \n",
-       "nuisance_expt_0_ET_fudge         -inf          inf         NaN        NaN  \n",
-       "nuisance_expt_1_ET_fudge         -inf          inf         NaN        NaN  "
+       "                          upper_bound  prior_mean  prior_std  \n",
+       "name                                                          \n",
+       "KE                                inf         NaN        NaN  \n",
+       "dH_E                              inf         NaN        NaN  \n",
+       "nuisance_dil_CT                   inf         NaN        NaN  \n",
+       "nuisance_dil_ET                   inf         NaN        NaN  \n",
+       "nuisance_expt_0_CT_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_1_CT_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge          inf         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge          inf         NaN        NaN  "
       ]
      },
-     "execution_count": 12,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "expt_list = [cablank1, cablank2, edtablank1, edtablank2, edtaca1, edtaca3, edtaca4, edtaca5, edtaca6, edtaca7] \n",
+    "\n",
+    "gm = linkage.GlobalModel(model_name=\"CaEDTA\",\n",
+    "                         expt_list=expt_list)\n",
+    "\n",
     "f = dataprob.setup(gm.model_normalized,\n",
     "                   vector_first_arg=True,\n",
+    "                   method=\"ml\",\n",
     "                   fit_parameters=gm.parameter_names)\n",
     "\n",
-    "f.param_df.loc[\"KE\",\"guess\"] = 17\n",
-    "f.param_df.loc[\"KE\",\"upper_bound\"] = 25\n",
-    "f.param_df.loc[\"KE\",\"lower_bound\"] = 0\n",
+    "f.param_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "293deeb5-170a-4b1d-9261-8366c78b2423",
+   "metadata": {},
+   "source": [
+    "#### Do fit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "4ac7eaa7-d428-497a-8bb9-1e6d36580023",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Parameters\n",
+    "\n",
+    "f.param_df.loc[\"KE\",\"guess\"] = 13\n",
+    "f.param_df.loc[\"KE\",\"upper_bound\"] = 20\n",
+    "f.param_df.loc[\"KE\",\"lower_bound\"] = 5\n",
+    "f.param_df.loc[\"KE\",\"fixed\"] = False\n",
     "\n",
-    "f.param_df.loc[\"nuisance_expt_0_ET_fudge\",\"guess\"] = 1.1\n",
-    "f.param_df.loc[\"nuisance_expt_0_ET_fudge\",\"fixed\"] = True\n",
+    "f.param_df.loc[\"dH_E\",\"guess\"] = -11970\n",
+    "f.param_df.loc[\"dH_E\",\"upper_bound\"] = -11500\n",
+    "f.param_df.loc[\"dH_E\",\"lower_bound\"] = -12000\n",
+    "f.param_df.loc[\"dH_E\",\"fixed\"] = False\n",
     "\n",
-    "f.param_df.loc[\"nuisance_expt_1_ET_fudge\",\"guess\"] = 1.1\n",
-    "f.param_df.loc[\"nuisance_expt_1_ET_fudge\",\"fixed\"] = True\n",
+    "# Get all parameter names containing 'nuisance_expt' and 'ET_fudge'\n",
+    "fudge_params = [col for col in f.param_df.index if 'nuisance_expt' in col]\n",
     "\n",
-    "f.fit(y_obs=gm.y_obs_normalized,\n",
-    "      y_std=gm.y_std_normalized)\n",
+    "# Link all fudge parameters (except 0) to the first one\n",
+    "for param in fudge_params:\n",
+    "        f.param_df.loc[param, 'guess'] = 1.1\n",
+    "        f.param_df.loc[param, 'fixed'] = True\n",
+    "        f.param_df.loc[param, 'lower_bound'] = -2\n",
+    "        f.param_df.loc[param, 'upper_bound'] = 2\n",
     "\n",
-    "f.fit_df"
+    "f.param_df.loc[\"nuisance_dil_CT\",\"upper_bound\"] = 200\n",
+    "f.param_df.loc[\"nuisance_dil_CT\",\"lower_bound\"] = -400\n",
+    "\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"upper_bound\"] = 200\n",
+    "f.param_df.loc[\"nuisance_dil_ET\",\"lower_bound\"] = -200\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "b113d0dc-7f14-469e-b604-a78a235cceac",
+   "execution_count": 14,
+   "id": "d8843415-d4f1-4d06-be1e-dc55108a2a16",
    "metadata": {},
    "outputs": [
     {
@@ -288,10 +464,13 @@
        "  \n",
        "    \n",
        "      \n",
-       "      description\n",
-       "      is_good\n",
-       "      value\n",
-       "      message\n",
+       "      name\n",
+       "      guess\n",
+       "      fixed\n",
+       "      lower_bound\n",
+       "      upper_bound\n",
+       "      prior_mean\n",
+       "      prior_std\n",
        "    \n",
        "    \n",
        "      name\n",
@@ -299,125 +478,241 @@
        "      \n",
        "      \n",
        "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
        "    \n",
        "  \n",
        "  \n",
        "    \n",
-       "      success\n",
-       "      fit success status\n",
+       "      KE\n",
+       "      KE\n",
+       "      13.0\n",
+       "      False\n",
+       "      5.0\n",
+       "      20.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      dH_E\n",
+       "      dH_E\n",
+       "      -11970.0\n",
+       "      False\n",
+       "      -12000.0\n",
+       "      -11500.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_dil_CT\n",
+       "      nuisance_dil_CT\n",
+       "      0.0\n",
+       "      False\n",
+       "      -400.0\n",
+       "      200.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_dil_ET\n",
+       "      nuisance_dil_ET\n",
+       "      0.0\n",
+       "      False\n",
+       "      -200.0\n",
+       "      200.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_0_CT_fudge\n",
+       "      nuisance_expt_0_CT_fudge\n",
+       "      1.1\n",
        "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_1_CT_fudge\n",
+       "      nuisance_expt_1_CT_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      \n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      num_obs\n",
-       "      number of observations\n",
+       "      nuisance_expt_2_ET_fudge\n",
+       "      nuisance_expt_2_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      66\n",
-       "      \n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      num_param\n",
-       "      number of fit parameters\n",
+       "      nuisance_expt_3_ET_fudge\n",
+       "      nuisance_expt_3_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      3\n",
-       "      There are 63 more observations than fit parame...\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      lnL\n",
-       "      log likelihood\n",
+       "      nuisance_expt_4_ET_fudge\n",
+       "      nuisance_expt_4_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      129.67464\n",
-       "      \n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      chi2\n",
-       "      chi^2 goodness-of-fit\n",
+       "      nuisance_expt_5_ET_fudge\n",
+       "      nuisance_expt_5_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      1.0\n",
-       "      A p-value of 1.000e+00 for the a goodness-of-f...\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      reduced_chi2\n",
-       "      reduced chi^2\n",
-       "      False\n",
-       "      0.280023\n",
-       "      A reduced chi^2 value of 0.280 may mean the mo...\n",
+       "      nuisance_expt_6_ET_fudge\n",
+       "      nuisance_expt_6_ET_fudge\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      mean0_resid\n",
-       "      t-test for residual mean != 0\n",
+       "      nuisance_expt_7_ET_fudge\n",
+       "      nuisance_expt_7_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      0.189692\n",
-       "      A p-value of 1.897e-01 for the one-sample t-te...\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      durbin-watson\n",
-       "      Durbin-Watson test for correlated residuals\n",
+       "      nuisance_expt_8_ET_fudge\n",
+       "      nuisance_expt_8_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      1.830258\n",
-       "      A Durbin-Watson test-statistic of 1.830 is con...\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "    \n",
-       "      ljung-box\n",
-       "      Ljung-Box test for correlated residuals\n",
+       "      nuisance_expt_9_ET_fudge\n",
+       "      nuisance_expt_9_ET_fudge\n",
+       "      1.1\n",
        "      True\n",
-       "      0.998879\n",
-       "      A p-value of 9.989e-01 for the Ljung-Box test ...\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
        "    \n",
        "  \n",
        "\n",
        ""
       ],
       "text/plain": [
-       "                                               description  is_good  \\\n",
-       "name                                                                  \n",
-       "success                                 fit success status     True   \n",
-       "num_obs                             number of observations     True   \n",
-       "num_param                         number of fit parameters     True   \n",
-       "lnL                                         log likelihood     True   \n",
-       "chi2                                 chi^2 goodness-of-fit     True   \n",
-       "reduced_chi2                                 reduced chi^2    False   \n",
-       "mean0_resid                  t-test for residual mean != 0     True   \n",
-       "durbin-watson  Durbin-Watson test for correlated residuals     True   \n",
-       "ljung-box          Ljung-Box test for correlated residuals     True   \n",
+       "                                              name    guess  fixed  \\\n",
+       "name                                                                 \n",
+       "KE                                              KE     13.0  False   \n",
+       "dH_E                                          dH_E -11970.0  False   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT      0.0  False   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET      0.0  False   \n",
+       "nuisance_expt_0_CT_fudge  nuisance_expt_0_CT_fudge      1.1   True   \n",
+       "nuisance_expt_1_CT_fudge  nuisance_expt_1_CT_fudge      1.1   True   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge      1.1   True   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge      1.1   True   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.1   True   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.1   True   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge      1.1   True   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge      1.1   True   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge      1.1   True   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge      1.1   True   \n",
        "\n",
-       "                   value                                            message  \n",
-       "name                                                                         \n",
-       "success             True                                                     \n",
-       "num_obs               66                                                     \n",
-       "num_param              3  There are 63 more observations than fit parame...  \n",
-       "lnL            129.67464                                                     \n",
-       "chi2                 1.0  A p-value of 1.000e+00 for the a goodness-of-f...  \n",
-       "reduced_chi2    0.280023  A reduced chi^2 value of 0.280 may mean the mo...  \n",
-       "mean0_resid     0.189692  A p-value of 1.897e-01 for the one-sample t-te...  \n",
-       "durbin-watson   1.830258  A Durbin-Watson test-statistic of 1.830 is con...  \n",
-       "ljung-box       0.998879  A p-value of 9.989e-01 for the Ljung-Box test ...  "
+       "                          lower_bound  upper_bound  prior_mean  prior_std  \n",
+       "name                                                                       \n",
+       "KE                                5.0         20.0         NaN        NaN  \n",
+       "dH_E                         -12000.0     -11500.0         NaN        NaN  \n",
+       "nuisance_dil_CT                -400.0        200.0         NaN        NaN  \n",
+       "nuisance_dil_ET                -200.0        200.0         NaN        NaN  \n",
+       "nuisance_expt_0_CT_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_1_CT_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge         -2.0          2.0         NaN        NaN  "
       ]
      },
-     "execution_count": 13,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "f.fit_quality"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1987676f-1c6a-44a3-995e-44af42226172",
-   "metadata": {},
-   "source": [
-    "#### Plot results"
+    "f.param_df"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a",
-   "metadata": {},
+   "execution_count": 15,
+   "id": "b788275b-29ef-4227-8a2e-8ac12903d281",
+   "metadata": {
+    "editable": true,
+    "scrolled": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   Iteration     Total nfev        Cost      Cost reduction    Step norm     Optimality   \n",
+      "       0              1         1.0910e+13                                    7.64e+13    \n",
+      "       1              2         1.6575e+12      9.25e+12       1.41e+02       1.30e+13    \n",
+      "       2              3         4.6221e+11      1.20e+12       1.16e+02       2.03e+12    \n",
+      "       3              4         2.9405e+11      1.68e+11       1.58e+02       2.83e+11    \n",
+      "       4              5         2.7383e+11      2.02e+10       1.16e+02       1.84e+10    \n",
+      "       5              6         2.7044e+11      3.39e+09       1.15e+02       1.25e+09    \n",
+      "       6              7         2.6955e+11      8.95e+08       4.07e+01       1.57e+09    \n",
+      "       7              8         2.6950e+11      5.00e+07       2.38e+00       1.44e+09    \n",
+      "       8              9         2.6950e+11      9.94e+05       1.58e-01       1.67e+08    \n",
+      "       9             10         2.6950e+11      1.80e+04       5.67e-02       2.00e+08    \n",
+      "      10             11         2.6950e+11      1.92e+03       2.12e-02       2.30e+07    \n",
+      "      11             12         2.6950e+11      2.59e+02       7.86e-03       2.77e+07    \n",
+      "      12             13         2.6950e+11      3.66e+01       2.96e-03       3.25e+06    \n",
+      "      13             14         2.6950e+11      5.15e+00       1.11e-03       3.91e+06    \n",
+      "      14             15         2.6950e+11      7.44e-01       4.17e-04       4.55e+05    \n",
+      "      15             16         2.6950e+11      8.23e-02       1.55e-04       5.49e+05    \n",
+      "      16             17         2.6950e+11      1.34e-01       5.83e-05       6.48e+04    \n",
+      "      17             27         2.6950e+11      0.00e+00       0.00e+00       6.48e+04    \n",
+      "`xtol` termination condition is satisfied.\n",
+      "Function evaluations 27, initial cost 1.0910e+13, final cost 2.6950e+11, first-order optimality 6.48e+04.\n"
+     ]
+    },
     {
      "data": {
       "text/html": [
@@ -470,70 +765,196 @@
        "    \n",
        "      KE\n",
        "      KE\n",
-       "      17.268426\n",
-       "      0.260890\n",
-       "      16.746914\n",
-       "      17.789939\n",
-       "      17.0\n",
+       "      16.433181\n",
+       "      0.000005\n",
+       "      16.433172\n",
+       "      16.433190\n",
+       "      13.0\n",
        "      False\n",
-       "      0.0\n",
-       "      25.0\n",
+       "      5.0\n",
+       "      20.0\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
        "    \n",
        "      dH_E\n",
        "      dH_E\n",
-       "      -11074.855329\n",
-       "      45.697703\n",
-       "      -11166.203736\n",
-       "      -10983.506923\n",
+       "      -11500.000000\n",
+       "      0.011240\n",
+       "      -11500.022116\n",
+       "      -11499.977884\n",
+       "      -11970.0\n",
+       "      False\n",
+       "      -12000.0\n",
+       "      -11500.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_dil_CT\n",
+       "      nuisance_dil_CT\n",
+       "      -400.000000\n",
+       "      0.004633\n",
+       "      -400.009117\n",
+       "      -399.990883\n",
        "      0.0\n",
        "      False\n",
-       "      -inf\n",
-       "      inf\n",
+       "      -400.0\n",
+       "      200.0\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
        "    \n",
        "      nuisance_dil_ET\n",
        "      nuisance_dil_ET\n",
-       "      -1.777205\n",
-       "      32.914516\n",
-       "      -67.572385\n",
-       "      64.017976\n",
+       "      32.828868\n",
+       "      0.000373\n",
+       "      32.828135\n",
+       "      32.829602\n",
        "      0.0\n",
        "      False\n",
-       "      -inf\n",
-       "      inf\n",
+       "      -200.0\n",
+       "      200.0\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
        "    \n",
-       "      nuisance_expt_0_ET_fudge\n",
-       "      nuisance_expt_0_ET_fudge\n",
+       "      nuisance_expt_0_CT_fudge\n",
+       "      nuisance_expt_0_CT_fudge\n",
        "      1.100000\n",
        "      NaN\n",
        "      NaN\n",
        "      NaN\n",
        "      1.1\n",
        "      True\n",
-       "      -inf\n",
-       "      inf\n",
+       "      -2.0\n",
+       "      2.0\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
        "    \n",
-       "      nuisance_expt_1_ET_fudge\n",
-       "      nuisance_expt_1_ET_fudge\n",
+       "      nuisance_expt_1_CT_fudge\n",
+       "      nuisance_expt_1_CT_fudge\n",
        "      1.100000\n",
        "      NaN\n",
        "      NaN\n",
        "      NaN\n",
        "      1.1\n",
        "      True\n",
-       "      -inf\n",
-       "      inf\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_2_ET_fudge\n",
+       "      nuisance_expt_2_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_3_ET_fudge\n",
+       "      nuisance_expt_3_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_4_ET_fudge\n",
+       "      nuisance_expt_4_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_5_ET_fudge\n",
+       "      nuisance_expt_5_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_6_ET_fudge\n",
+       "      nuisance_expt_6_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_7_ET_fudge\n",
+       "      nuisance_expt_7_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_8_ET_fudge\n",
+       "      nuisance_expt_8_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
+       "      NaN\n",
+       "      NaN\n",
+       "    \n",
+       "    \n",
+       "      nuisance_expt_9_ET_fudge\n",
+       "      nuisance_expt_9_ET_fudge\n",
+       "      1.100000\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      NaN\n",
+       "      1.1\n",
+       "      True\n",
+       "      -2.0\n",
+       "      2.0\n",
        "      NaN\n",
        "      NaN\n",
        "    \n",
@@ -542,38 +963,421 @@
        ""
       ],
       "text/plain": [
-       "                                              name      estimate        std  \\\n",
-       "name                                                                          \n",
-       "KE                                              KE     17.268426   0.260890   \n",
-       "dH_E                                          dH_E -11074.855329  45.697703   \n",
-       "nuisance_dil_ET                    nuisance_dil_ET     -1.777205  32.914516   \n",
-       "nuisance_expt_0_ET_fudge  nuisance_expt_0_ET_fudge      1.100000        NaN   \n",
-       "nuisance_expt_1_ET_fudge  nuisance_expt_1_ET_fudge      1.100000        NaN   \n",
+       "                                              name      estimate       std  \\\n",
+       "name                                                                         \n",
+       "KE                                              KE     16.433181  0.000005   \n",
+       "dH_E                                          dH_E -11500.000000  0.011240   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT   -400.000000  0.004633   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET     32.828868  0.000373   \n",
+       "nuisance_expt_0_CT_fudge  nuisance_expt_0_CT_fudge      1.100000       NaN   \n",
+       "nuisance_expt_1_CT_fudge  nuisance_expt_1_CT_fudge      1.100000       NaN   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge      1.100000       NaN   \n",
        "\n",
-       "                                low_95       high_95  guess  fixed  \\\n",
-       "name                                                                 \n",
-       "KE                           16.746914     17.789939   17.0  False   \n",
-       "dH_E                     -11166.203736 -10983.506923    0.0  False   \n",
-       "nuisance_dil_ET             -67.572385     64.017976    0.0  False   \n",
-       "nuisance_expt_0_ET_fudge           NaN           NaN    1.1   True   \n",
-       "nuisance_expt_1_ET_fudge           NaN           NaN    1.1   True   \n",
+       "                                low_95       high_95    guess  fixed  \\\n",
+       "name                                                                   \n",
+       "KE                           16.433172     16.433190     13.0  False   \n",
+       "dH_E                     -11500.022116 -11499.977884 -11970.0  False   \n",
+       "nuisance_dil_CT            -400.009117   -399.990883      0.0  False   \n",
+       "nuisance_dil_ET              32.828135     32.829602      0.0  False   \n",
+       "nuisance_expt_0_CT_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_1_CT_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_2_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_3_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_4_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_5_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_6_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_7_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_8_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_9_ET_fudge           NaN           NaN      1.1   True   \n",
        "\n",
        "                          lower_bound  upper_bound  prior_mean  prior_std  \n",
        "name                                                                       \n",
-       "KE                                0.0         25.0         NaN        NaN  \n",
-       "dH_E                             -inf          inf         NaN        NaN  \n",
-       "nuisance_dil_ET                  -inf          inf         NaN        NaN  \n",
-       "nuisance_expt_0_ET_fudge         -inf          inf         NaN        NaN  \n",
-       "nuisance_expt_1_ET_fudge         -inf          inf         NaN        NaN  "
+       "KE                                5.0         20.0         NaN        NaN  \n",
+       "dH_E                         -12000.0     -11500.0         NaN        NaN  \n",
+       "nuisance_dil_CT                -400.0        200.0         NaN        NaN  \n",
+       "nuisance_dil_ET                -200.0        200.0         NaN        NaN  \n",
+       "nuisance_expt_0_CT_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_1_CT_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge         -2.0          2.0         NaN        NaN  "
       ]
      },
-     "execution_count": 14,
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Run fit\n",
+    "\n",
+    "f.fit(\n",
+    "      y_obs=gm.y_obs_normalized,\n",
+    "      y_std=gm.y_std_normalized,\n",
+    "      #max_convergence_cycles=2,\n",
+    "      #use_ml_guess=False,\n",
+    "      #num_steps=100,\n",
+    "      #num_walkers=800, # number of markov chains to use in the analysis, default=100       \n",
+    "      method='trf',  # Algorithm to use for optimization\n",
+    "      jac='3-point',  # Method for computing the Jacobian matrix\n",
+    "      ftol=1e-15,  # Tolerance for termination by the change of the cost function\n",
+    "      xtol=1e-15,  # Tolerance for termination by the change of the independent variables\n",
+    "      gtol=1e-15,  # Tolerance for termination by the norm of the gradient\n",
+    "      x_scale='jac',  # Scaling of the variables\n",
+    "      #loss='arctan',  # Loss function for dealing with outliers\n",
+    "      #f_scale=0.01  # Soft margin between inlier and outlier residuals\n",
+    "      max_nfev=100,  # Maximum number of function evaluations\n",
+    "      verbose=2  # Level of algorithm's verbosity\n",
+    "     )\n",
+    "\n",
+    "f.fit_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "b113d0dc-7f14-469e-b604-a78a235cceac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#f.fit_quality"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1987676f-1c6a-44a3-995e-44af42226172",
+   "metadata": {},
+   "source": [
+    "#### Plot results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
nameestimatestdlow_95high_95guessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE16.4331810.00000516.43317216.43319013.0False5.020.0NaNNaN
dH_EdH_E-11500.0000000.011240-11500.022116-11499.977884-11970.0False-12000.0-11500.0NaNNaN
nuisance_dil_CTnuisance_dil_CT-400.0000000.004633-400.009117-399.9908830.0False-400.0200.0NaNNaN
nuisance_dil_ETnuisance_dil_ET32.8288680.00037332.82813532.8296020.0False-200.0200.0NaNNaN
nuisance_expt_0_CT_fudgenuisance_expt_0_CT_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_1_CT_fudgenuisance_expt_1_CT_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_2_ET_fudgenuisance_expt_2_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_3_ET_fudgenuisance_expt_3_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_4_ET_fudgenuisance_expt_4_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_5_ET_fudgenuisance_expt_5_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_6_ET_fudgenuisance_expt_6_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_7_ET_fudgenuisance_expt_7_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_8_ET_fudgenuisance_expt_8_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
nuisance_expt_9_ET_fudgenuisance_expt_9_ET_fudge1.100000NaNNaNNaN1.1True-2.02.0NaNNaN
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                                              name      estimate       std  \\\n",
+       "name                                                                         \n",
+       "KE                                              KE     16.433181  0.000005   \n",
+       "dH_E                                          dH_E -11500.000000  0.011240   \n",
+       "nuisance_dil_CT                    nuisance_dil_CT   -400.000000  0.004633   \n",
+       "nuisance_dil_ET                    nuisance_dil_ET     32.828868  0.000373   \n",
+       "nuisance_expt_0_CT_fudge  nuisance_expt_0_CT_fudge      1.100000       NaN   \n",
+       "nuisance_expt_1_CT_fudge  nuisance_expt_1_CT_fudge      1.100000       NaN   \n",
+       "nuisance_expt_2_ET_fudge  nuisance_expt_2_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_3_ET_fudge  nuisance_expt_3_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_4_ET_fudge  nuisance_expt_4_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_5_ET_fudge  nuisance_expt_5_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_6_ET_fudge  nuisance_expt_6_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_7_ET_fudge  nuisance_expt_7_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_8_ET_fudge  nuisance_expt_8_ET_fudge      1.100000       NaN   \n",
+       "nuisance_expt_9_ET_fudge  nuisance_expt_9_ET_fudge      1.100000       NaN   \n",
+       "\n",
+       "                                low_95       high_95    guess  fixed  \\\n",
+       "name                                                                   \n",
+       "KE                           16.433172     16.433190     13.0  False   \n",
+       "dH_E                     -11500.022116 -11499.977884 -11970.0  False   \n",
+       "nuisance_dil_CT            -400.009117   -399.990883      0.0  False   \n",
+       "nuisance_dil_ET              32.828135     32.829602      0.0  False   \n",
+       "nuisance_expt_0_CT_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_1_CT_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_2_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_3_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_4_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_5_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_6_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_7_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_8_ET_fudge           NaN           NaN      1.1   True   \n",
+       "nuisance_expt_9_ET_fudge           NaN           NaN      1.1   True   \n",
+       "\n",
+       "                          lower_bound  upper_bound  prior_mean  prior_std  \n",
+       "name                                                                       \n",
+       "KE                                5.0         20.0         NaN        NaN  \n",
+       "dH_E                         -12000.0     -11500.0         NaN        NaN  \n",
+       "nuisance_dil_CT                -400.0        200.0         NaN        NaN  \n",
+       "nuisance_dil_ET                -200.0        200.0         NaN        NaN  \n",
+       "nuisance_expt_0_CT_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_1_CT_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_2_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_3_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_4_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_5_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_6_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_7_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_8_ET_fudge         -2.0          2.0         NaN        NaN  \n",
+       "nuisance_expt_9_ET_fudge         -2.0          2.0         NaN        NaN  "
+      ]
+     },
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "
"
       ]
@@ -590,80 +1394,60 @@
     "             \"elinewidth\":1,\n",
     "             \"capsize\":2}\n",
     "\n",
-    "color_order = [\"red\",\"black\"]\n",
-    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
     "\n",
+    "color_order = [\"red\",\"black\", \"blue\", \"green\", \"purple\", \"black\", \"brown\", \"gray\", \"orange\", \"lightblue\", \"lightgreen\"]\n",
+    "\n",
+    "\n",
+    "fig, ax = plt.subplots(1,figsize=(6,6))\n",
     "out_df = gm.as_df.copy()\n",
     "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n",
-    "\n",
     "for i in np.unique(out_df.expt_id):\n",
     "    \n",
     "    style[\"edgecolor\"] = color_order[i]\n",
     "    err_style[\"color\"] = color_order[i]\n",
-    "\n",
     "    mask = out_df[\"expt_id\"] == i\n",
     "    this_df = out_df.loc[mask,:]\n",
     "    \n",
-    "    x_values = np.cumsum(this_df[\"injection\"])\n",
-    "    y_values = np.array(this_df[\"y_obs\"])\n",
+    "    x_values = np.cumsum(this_df[\"injection\"])[1:]  # Skip first point\n",
+    "    y_values = np.array(this_df[\"y_obs\"])[1:]       # Skip first point\n",
     "    y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n",
+    "    y_err = y_err[1:]                               # Skip first point\n",
     "    this_y_calc = y_calc[mask]/this_df[\"injection\"]\n",
-    "\n",
-    "    y_values = y_values/this_df[\"injection\"]\n",
+    "    this_y_calc = this_y_calc[1:]                   # Skip first point \n",
+    "    y_values = y_values/this_df[\"injection\"][1:]    # Skip first point\n",
     "    \n",
     "    ax.scatter(x_values,y_values,**style)\n",
     "    ax.errorbar(x=x_values,\n",
     "                y=y_values,\n",
     "                yerr=y_err,\n",
     "                **err_style)\n",
-    "\n",
     "    ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n",
     "    \n",
-    "\n",
     "plt.xlabel(\"injection\")\n",
     "plt.ylabel(\"heat\")\n",
-    "\n",
     "f.fit_df"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "d72d8bfd-d925-445e-967d-4f6603621a2d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "fig = dataprob.plot_corner(f)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig = dataprob.plot_summary(f)\n"
    ]
@@ -675,6 +1459,22 @@
    "metadata": {},
    "outputs": [],
    "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "86fa86ea-9a3e-46ac-a458-23b83228b9bf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "441a74cb-cbfb-4a7d-b2f6-f40b0d5e59ba",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -693,7 +1493,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/readheatstest.ipynb b/notebooks/readheatstest.ipynb
index 6591da2..b84250a 100644
--- a/notebooks/readheatstest.ipynb
+++ b/notebooks/readheatstest.ipynb
@@ -2,12 +2,12 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 1,
    "id": "decd9f42-6209-4a88-9a15-eb0b32cb2505",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
+    "import os\n",
     "import pandas as pd\n",
     "\n",
     "def read_heats_file(dh_file,uncertainty,output_file):\n",
@@ -22,8 +22,8 @@
     "    output_file : str\n",
     "        name of file to write out data\n",
     "    uncertainty : float\n",
-    "        user estimate of the uncertainty on each measured heat\n",
-    "\n",
+    "        user estimate of the uncertainty on each measured heat,\n",
+    "        treated as a percentage (e.g., 0.05 for 5%).\n",
     "    Returns\n",
     "    -------\n",
     "    meta_data : dict\n",
@@ -53,13 +53,19 @@
     "        shots.append(float(col[0]))\n",
     "        heats.append(float(col[1]))\n",
     "\n",
-    "    # Make a list of uncertainty repeated once for every observed heat\n",
-    "    heats_stdev = [uncertainty for i in range(len(heats))]\n",
+    "    # Calculate heat_stdev as a percentage of each heat value\n",
+    "    heats_stdev = [h * uncertainty for h in heats]\n",
+    "\n",
+    "    # Create the ignore_point column values\n",
+    "    ignore_point_column = [False for _ in range(len(heats))]\n",
+    "    if len(ignore_point_column) > 0:\n",
+    "        ignore_point_column[0] = True\n",
     "\n",
     "    # Construct dataframe with data and write out a spreadsheet\n",
     "    to_df = {\"injection\":shots,\n",
     "             \"heat\":heats,\n",
-    "             \"heat_stdev\":heats_stdev}\n",
+    "             \"heat_stdev\":heats_stdev,\n",
+    "             \"ignore_point\":ignore_point_column}\n",
     "    df = pd.DataFrame(to_df)\n",
     "    df.to_csv(output_file,index=False)\n",
     "\n",
@@ -70,12 +76,13 @@
     "    out[\"titrant_conc\"] = titrant_syringe_conc\n",
     "    out[\"cell_volume\"] = titrant_syringe_conc\n",
     "\n",
-    "\n"
+    "\n",
+    "    return out"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "id": "3cb1902e-ad74-482a-b9a9-86b676fe6698",
    "metadata": {},
    "outputs": [],
@@ -86,8 +93,8 @@
     "\n",
     "## Running this script twice will overwrite any previous runs of the code\n",
     "\n",
-    "inputdir = r\"C:/Users/willi/linkage/notebooks/rawdata\"\n",
-    "outputdir = r\"C:/Users/willi/linkage/notebooks/processed_data\" # Specify your desired output directory\n",
+    "inputdir = r\"C:\\Users\\willi\\Desktop\\20250625\"\n",
+    "outputdir = r\"C:\\Users\\willi\\Desktop\\20250625processed\" # Specify your desired output directory\n",
     "\n",
     "def iterate_dh_to_csv(inputdir, outputdir):\n",
     "    for dirpath, dirnames, filenames in os.walk(inputdir):\n",
@@ -110,21 +117,119 @@
     "\n",
     "\n",
     "\n",
-    "iterate_and_process(inputdir, outputdir)"
+    "iterate_dh_to_csv(inputdir, outputdir)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "9e905fab-5dbb-481f-aa71-3160c51d7c3e",
+   "execution_count": 1,
+   "id": "e632eff9-2e83-48b8-b34b-ffc43005b2cf",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "\n",
+    "def add_ignore_point_column_if_missing(folder_path):\n",
+    "    \"\"\"\n",
+    "    Iterates through CSV files in the given folder and its subdirectories.\n",
+    "    If a CSV does not have an 'ignore_point' column, it adds one.\n",
+    "    In the new 'ignore_point' column, the first row will be True, \n",
+    "    and subsequent rows will be False. If the CSV is empty, an empty\n",
+    "    'ignore_point' column is added.\n",
+    "    \"\"\"\n",
+    "    for dirpath, dirnames, filenames in os.walk(folder_path):\n",
+    "        for filename in filenames:\n",
+    "            if filename.lower().endswith('.csv'):\n",
+    "                filepath = os.path.join(dirpath, filename)\n",
+    "                df = pd.read_csv(filepath)\n",
+    "                \n",
+    "                if 'ignore_point' not in df.columns:\n",
+    "                    if not df.empty:\n",
+    "                        # Create the new column with False for all rows initially\n",
+    "                        ignore_values = [False] * len(df)\n",
+    "                        # Set the first row to True\n",
+    "                        ignore_values[0] = True\n",
+    "                        df['ignore_point'] = ignore_values\n",
+    "                    else:\n",
+    "                        # If DataFrame is empty (no data rows), just add an empty column\n",
+    "                        df['ignore_point'] = [] \n",
+    "                    \n",
+    "                    df.to_csv(filepath, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2c150df5-1645-4105-853e-969a0c3c8d2e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "folder_path = r\"C:\\Users\\willi\\linkage\\notebooks\\data\"\n",
+    "\n",
+    "add_ignore_point_column_if_missing(folder_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e32a4c77-dbc4-4e88-aab7-7ef9a0d63228",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "\n",
+    "def update_heat_stdev_column(folder_path, uncertainty_percentage):\n",
+    "    \"\"\"\n",
+    "    Iterates through CSV files in the given folder and its subdirectories.\n",
+    "    If a CSV has both 'heat' and 'heat_stdev' columns, it recalculates\n",
+    "    the 'heat_stdev' column using the formula: abs(heat * uncertainty_percentage).\n",
+    "    \"\"\"\n",
+    "    for dirpath, dirnames, filenames in os.walk(folder_path):\n",
+    "        for filename in filenames:\n",
+    "            if filename.lower().endswith('.csv'):\n",
+    "                filepath = os.path.join(dirpath, filename)\n",
+    "                df = pd.read_csv(filepath)\n",
+    "                \n",
+    "                # Check if both 'heat' and 'heat_stdev' columns exist\n",
+    "                if 'heat' in df.columns and 'heat_stdev' in df.columns:\n",
+    "                    # Calculate heat_stdev and ensure it's positive\n",
+    "                    df['heat_stdev'] = (df['heat'] * uncertainty_percentage).abs()\n",
+    "                    \n",
+    "                    df.to_csv(filepath, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "cfd7005a-2ccb-41e1-be6f-e89536976879",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "folder_path = r\"C:\\Users\\willi\\linkage\\notebooks\\data\"\n",
+    "uncertainty_percentage = 0.001\n",
+    "\n",
+    "update_heat_stdev_column(folder_path, uncertainty_percentage)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "baf03c7e-09b9-4952-ab8a-6a4ca05c1cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "folder_path = r\"S:\\Harmslab\\ITC2\"\n",
+    "uncertainty_percentage = 0.001\n",
+    "\n",
+    "update_heat_stdev_column(folder_path, uncertainty_percentage)"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "f665fa30-63e2-4eb7-bc6e-86aaadd6e681",
+   "id": "3a77b73e-926e-4d31-a0a1-bf05dfd43a8d",
    "metadata": {},
    "outputs": [],
    "source": []
diff --git a/pyproject.toml b/pyproject.toml
index c03703f..0076cd9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -21,7 +21,9 @@ dependencies = [
   "pandas",
   "matplotlib",
   "openpyxl",
-  "dataprob"
+  "dataprob",
+  "sympy",
+  "scipy",
 ]
 
 requires-python = ">=3.10"
diff --git a/src/linkage/global_model/global_model.py b/src/linkage/global_model/global_model.py
index 10c77c6..0e83ee5 100644
--- a/src/linkage/global_model/global_model.py
+++ b/src/linkage/global_model/global_model.py
@@ -4,81 +4,84 @@
 
 import numpy as np
 import pandas as pd
-
 import copy
+import warnings
+import traceback
 
 class GlobalModel:
-    """
-    This class brings together a list of experiments and a thermodynamic model
-    and generates an integrated model. This model will have the following 
-    parameters:
-    
-    + equilibrium constants from model
-    + a nuisance concentration parameter for each experiment (if requested)
-    + enthalpies for each of the model equilibria and heats of dilution for 
-      titrating species (if at least one ITC experiment is passed in)
-
-    This class also:
-    
-    + Regularizes the signal from experimental types. For example,
-      the heats from across all itc experiments will be transformed by
-      (heat - mean(all_heats))/std(all_heats), where all_heats comes from all 
-      itc experiments loaded. The same transformation will be done to each
-      spectroscopic channel. This puts all experiment types on the same scale
-      when a residual is calculated. 
-
-    + Weights each observation in each experiment by the number of
-      points in that experiment. This means that an experiment with more points 
-      will have the same weight overall contribution to the regression as an
-      experiment with fewer points. 
-    """
-
-    def __init__(self,
-                 expt_list,
-                 model_name):
+    def __init__(self, expt_list, model_name, model_spec=None):
         """
-        Initialize a global fit.
-        
+        This class integrates experimental data with thermodynamic modeling by combining 
+        a list of experiments with a specified model. The integrated model includes:
+
+        - Equilibrium constants derived from the thermodynamic model
+        - Optional nuisance concentration parameters for each experiment
+        - Enthalpies for model equilibria and heats of dilution for titrating species 
+        (when ITC experiments are included)
+
+        Key features:
+        - Signal normalization: Transforms experimental signals (e.g., ITC heats, 
+        spectroscopic channels) using (value - mean)/std across all experiments of 
+        the same type, ensuring consistent scaling for residual calculations
+        - Balanced weighting: Weights observations inversely to the number of data 
+        points in each experiment, ensuring equal contribution regardless of 
+        experiment size
+
         Parameters
         ----------
         expt_list : list
-            list of experiments with loaded observations
+            List of experiments with loaded observations
         model_name : str
-            name of model to use to calculate concentrations
+            Name of the thermodynamic model to use for concentration calculations
+        model_spec : str, optional
+            Model specification string for generic models. If None, a manually defined 
+            model class is assumed.
         """
 
         # Store model name and experiment list
         self._model_name = model_name
         self._expt_list = copy.deepcopy(expt_list)
-    
+        self._model_spec = model_spec
+
         # Load the model
         self._load_model()
 
-        # Load experimental data. The final output of this 
+        # Load experimental data
         self._get_expt_std_scalar()
         self._get_expt_normalization()
         self._load_observables()
 
         self._get_enthalpy_param()
         self._get_expt_fudge()
-        
+
         # Create points that allow calculation of observations
         self._build_point_map()
 
+        # Add confirmation printout for analytical Jacobian
+        if self._model_name == "GenericBindingModel":
+            # Check the underlying binding model to see if it successfully created the jacobian function.
+            if hasattr(self._bm, "jacobian_function") and self._bm.jacobian_function is not None:
+                print("INFO: Analytical Jacobian was successfully generated for the binding model.")
+            else:
+                # The warning from GenericBindingModel's __init__ will provide the specific error.
+                # This just serves as a high-level confirmation of failure.
+                print("WARNING: Analytical Jacobian could not be generated. Fitter will use numerical methods.")
+
+
     def _load_model(self):
         """
         Load and initialize the thermodynamic linkage model. 
         """
-        
+
         # Make a list of all classes in linkage.models
         available_models = {}
         for k in linkage.models.__dict__:
             if k.startswith("_"):
                 continue
-        
+
             if issubclass(type(linkage.models.__dict__[k]),type):
                 available_models[k] = linkage.models.__dict__[k]
-        
+
         # Make sure the model the user specified is found 
         if self._model_name not in available_models:
             err = f"model_name '{self._model_name}' not recognized. It should be one of:\n"
@@ -86,9 +89,17 @@ def _load_model(self):
                 err += f"    {k}\n"
             err += "\n"
             raise ValueError(err)
-        
+
         # Initialize binding model
-        self._bm = available_models[self._model_name]()
+        ModelClass = available_models[self._model_name]
+        if self._model_name == "GenericBindingModel":
+            if self._model_spec is None:
+                raise ValueError("model_spec must be provided for GenericBindingModel")
+            self._bm = ModelClass(model_spec=self._model_spec)
+        else:
+            if self._model_spec is not None:
+                print("Warning: model_spec provided but not used for non-generic model")
+            self._bm = ModelClass()
 
         # Record names of the model parameters
         self._parameter_names = []
@@ -100,7 +111,7 @@ def _load_model(self):
         # Record indexes spanning parameter guesses
         self._bm_param_start_idx = 0
         self._bm_param_end_idx = len(self._parameter_names) - 1
-            
+
     def _get_expt_std_scalar(self):
         """
         Second, we normalize each experiment to the number of points in that 
@@ -109,7 +120,7 @@ def _get_expt_std_scalar(self):
             theta = num_obs/sum(num_obs)
             y_std = y_std*(1 - theta + np.max(theta))
         """
-        
+
         # Number of points contributed by each experiment
         points_per_expt = []
         for expt in self._expt_list:
@@ -127,7 +138,6 @@ def _get_expt_std_scalar(self):
         theta = points_per_expt/np.sum(points_per_expt)
         self._expt_std_scalar = 1 - theta + np.max(theta)
 
-    
     def _get_expt_normalization(self):
         """
         First, each unique 'obs' seen (e.g. heat, cd222, etc.) is normalized to
@@ -145,19 +155,19 @@ def _get_expt_normalization(self):
         for expt in self._expt_list:
 
             for obs in expt.observables:
-                
+
                 keep = np.logical_not(expt.expt_data["ignore_point"])
                 obs_values = list(expt.expt_data.loc[keep,obs])
                 if obs not in obs_values_seen:
                     obs_values_seen[obs] = []
-                
+
                 obs_values_seen[obs].extend(obs_values)
 
         # Create a normalization_params dictionary that keys obs to the mean and
         # std of that obs. 
         self._normalization_params = {}
         for obs in obs_values_seen:
-            
+
             values = np.array(obs_values_seen[obs])
             values = values[np.logical_not(np.isnan(values))]
             if len(values) == 0:
@@ -166,7 +176,7 @@ def _get_expt_normalization(self):
             else:
                 mean_value = np.mean(values)
                 std_value = np.std(values)
-            
+
             self._normalization_params[obs] = [mean_value,std_value]
 
     def _load_observables(self):
@@ -195,7 +205,7 @@ def _load_observables(self):
             not_in_expt = set(self._bm.macro_species) - set(expt.expt_concs.columns)
             for missing in not_in_expt:
                 expt.add_expt_conc_column(new_column=missing)
-        
+
             # For each observable
             for obs in expt.observables:
 
@@ -239,25 +249,14 @@ def _load_observables(self):
         self._y_norm_mean = np.array(self._y_norm_mean)
         self._y_norm_std = np.array(self._y_norm_std)
         self._y_std_scalar = np.array(self._y_std_scalar)
-        
+
         self._y_obs_normalized = np.array(self._y_obs_normalized)
         self._y_std_normalized = np.array(self._y_std_normalized)
 
-
     def _get_enthalpy_param(self):
         """
-        Deal with enthalpy terms if needed. 
-        
-        Enthalpy change over a titration step is determined by change in
-        the concentration of microscopic species from the equilibrium. 
-        Ideally, there is a single species on one side of the reaction, 
-        so we can simply measure the change in the concentration of that
-        species. This block of code figures out which side of the 
-        equilibrium has fewer species and declares that the "product" for
-        accounting purposes. dh_sign records whether this is the right
-        side of the reaction (forward) with +1 or the left side of the 
-        reaction (backward) with -1. By applying dh_sign, the final 
-        enthalpy is always correct relative to the reaction definition. 
+        Deal with enthalpy terms if needed.
+        ... (docstring unchanged) ...
         """
 
         # Look for an ITC experiment
@@ -268,28 +267,19 @@ def _get_enthalpy_param(self):
                     need_enthalpies = True
                     break
 
-        # If we do not need enthalpies, return without doing anything
-        if not need_enthalpies:    
-            return 
+        if not need_enthalpies:
+            return
 
-        # Index of first enthalpy
         self._dh_param_start_idx = len(self._parameter_names)
-        
-        # ------------------------------------------------------------------
-        # Reaction enthalpies
 
+        # Reaction enthalpies
         self._dh_sign = []
         self._dh_product_mask = []
-        
-        # Create an enthalpy term (with associated dh_sign and dh_product_mask)
-        # for each equilibrium. 
-        for k in self._bm.equilibria:
 
-            # Get products and reactants of this equilibrium
+        for k in self._bm.equilibria:
             reactants = self._bm.equilibria[k][0]
             products = self._bm.equilibria[k][1]
 
-            # Figure out if products or reactants side has fewer species
             if len(products) <= len(reactants):
                 self._dh_sign.append(1.0)
                 key_species = products[:]
@@ -297,31 +287,21 @@ def _get_enthalpy_param(self):
                 self._dh_sign.append(-1.0)
                 key_species = reactants[:]
 
-            # Create a mask that lets us grab the species we need to track 
-            # from the _micro_array array. 
             self._dh_product_mask.append(np.isin(self._bm.micro_species,
                                                     key_species))
 
-        # Record enthalpies as parameters
         for s in self._bm.param_names:
             self._parameter_names.append(f"dH_{s[1:]}")
             self._parameter_guesses.append(0.0)
 
-        # ------------------------------------------------------------------
-        # Heats of dilution. 
-
-        # Figure out which species are being diluted when they go into the
-        # cell from the syringe. 
+        # Heats of dilution
         to_dilute = []
         for expt in self._expt_list:
             for obs in expt.observables:
                 if expt.observables[obs]["type"] == "itc":
                     to_dilute.extend(expt.titrating_macro_species)
         to_dilute = list(set(to_dilute))
-        
-        # Add heat of dilution parameters to the parameter array. Construct
-        # the dilution_mask to indicate which macro species these 
-        # correspond to. 
+
         dh_dilution_mask = []
         for s in self._bm.macro_species:
             if s in to_dilute:
@@ -332,345 +312,321 @@ def _get_enthalpy_param(self):
                 dh_dilution_mask.append(False)
 
         self._dh_dilution_mask = np.array(dh_dilution_mask,dtype=bool)
-                
-        # Last enthalpy index is last entry
         self._dh_param_end_idx = len(self._parameter_names)  - 1
-    
+
     def _get_expt_fudge(self):
         """
         Fudge parameters account for uncertainty in one of the total
         concentrations each experiment. This is specified by `conc_to_float`
         when the `Experiment` class is initialized. 
         """
-
-        # Fudge parameters will be last parameters in the guess array   
         self._fudge_list = []
         for expt_counter, expt in enumerate(self._expt_list):
-            
-            # If an experiment has a conc_to_float specified, create a parameter
-            # and initialize it. 
             if expt.conc_to_float:
-
                 param_name = f"nuisance_expt_{expt_counter}_{expt.conc_to_float}_fudge"
                 self._parameter_names.append(param_name)
                 self._parameter_guesses.append(1.0)
-                
                 fudge_species_index = np.where(self._bm.macro_species == expt.conc_to_float)[0][0]
                 fudge_value_index = len(self._parameter_names) - 1
-                
                 self._fudge_list.append((fudge_species_index,fudge_value_index))
-                        
             else:
                 self._fudge_list.append(None)
-    
 
     def _add_point(self,point_idx,expt_idx,obs):
-
-        # Information about observable and experimental data
         expt = self._expt_list[expt_idx]
         obs_info = expt.observables[obs]
-        
         data_idx = expt.expt_data.index[point_idx]
-        total_volume = float(expt.expt_concs.loc[data_idx,"volume"])
-        injection_volume = float(expt.expt_data.loc[data_idx,"injection"])
+        total_volume = float(expt.expt_concs.loc[data_idx, "volume"])
+        injection_volume = float(expt.expt_data.loc[data_idx, "injection"])
 
-        if expt.expt_data.loc[data_idx,"ignore_point"]:
+        if expt.expt_data.loc[data_idx, "ignore_point"]:
             return
-            
-        point_kwargs = {"idx":point_idx,
-                        "expt_idx":expt_idx,
-                        "obs_key":obs,
-                        "micro_array":self._micro_arrays[-1],
-                        "macro_array":self._macro_arrays[-1],
-                        "del_macro_array":self._del_macro_arrays[-1],
-                        "total_volume":total_volume,
-                        "injection_volume":injection_volume}
 
-        if obs_info["type"] == "spec":
+        point_kwargs = {"idx": point_idx,
+                        "expt_idx": expt_idx,
+                        "obs_key": obs,
+                        "micro_array": self._micro_arrays[-1],
+                        "macro_array": self._macro_arrays[-1],
+                        "del_macro_array": self._del_macro_arrays[-1],
+                        "total_volume": total_volume,
+                        "injection_volume": injection_volume}
 
-            obs_mask = np.isin(self._bm.micro_species,obs_info["microspecies"])
+        if obs_info["type"] == "spec":
+            obs_mask = np.isin(self._bm.micro_species, obs_info["microspecies"])
             denom = np.where(self._bm.macro_species == obs_info["macrospecies"])[0][0]
-
             point_kwargs["obs_mask"] = obs_mask
             point_kwargs["denom"] = denom
-
             pt = SpecPoint(**point_kwargs)
-            
         elif obs_info["type"] == "itc":
-            
             point_kwargs["dh_param_start_idx"] = self._dh_param_start_idx
             point_kwargs["dh_param_end_idx"] = self._dh_param_end_idx + 1
             point_kwargs["dh_sign"] = self._dh_sign
             point_kwargs["dh_product_mask"] = self._dh_product_mask
             point_kwargs["dh_dilution_mask"] = self._dh_dilution_mask
-
             pt = ITCPoint(**point_kwargs)
-
         else:
-            obs_type = obs_info["type"]
-            err = f"The obs type '{obs_type}' is not recognized\n"
-            raise ValueError(err)
+            raise ValueError(f"The obs type '{obs_info['type']}' is not recognized\n")
 
         self._points.append(pt)
 
     def _build_point_map(self):
-
-        # Lists of arrays that can be referenced by all points in the 
-        # experiments. There is an entry for each experiment. The values in 
-        # these arrays are set globally. 
         self._ref_macro_arrays = []
         self._macro_arrays = []
         self._micro_arrays = []
         self._del_macro_arrays = []
         self._expt_syringe_concs = []
-
-        # List of all points
         self._points = []
 
         for expt_counter, expt in enumerate(self._expt_list):
-
-            # Each experiment has:
-            
-            # 1. An array of microscopic species concentrations
             self._micro_arrays.append(np.ones((len(expt.expt_data),
-                                                len(self._bm.micro_species)),
-                                               dtype=float)*np.nan)
-
-            # 2. An array of macroscopic species concentrations
-            macro_array = np.array(expt.expt_concs.loc[:,self._bm.macro_species],
-                                   dtype=float).copy()
+                                            len(self._bm.micro_species)),
+                                            dtype=float)*np.nan)
+            
+            macro_array = np.zeros((len(expt.expt_data), len(self._bm.macro_species)))
+            for i, species in enumerate(self._bm.macro_species):
+                macro_array[:,i] = expt.expt_concs[species].values
             self._ref_macro_arrays.append(macro_array)
             self._macro_arrays.append(self._ref_macro_arrays[-1].copy())
-
-            # 3. An array of the change in macro species relative to syringe. 
+            
             syringe_concs = []
             for s in self._bm.macro_species:
                 if s in expt.syringe_contents:
                     syringe_concs.append(expt.syringe_contents[s])
                 else:
                     syringe_concs.append(0.0)
+            syringe_concs = np.array(syringe_concs, dtype=float)
             
-            syringe_concs = np.array(syringe_concs,dtype=float)
             self._expt_syringe_concs.append(syringe_concs)
             self._del_macro_arrays.append(syringe_concs - macro_array)
                     
-            # For each observable
             for obs in expt.observables:
-
-                # Go through each experimental point
                 for i in range(len(expt.expt_data)):
-
-                    # Add that point to the list of all points. The final list 
-                    # of points will exactly match the values in y_obs, y_std,
-                    # etc.
                     self._add_point(point_idx=i,
-                                    expt_idx=expt_counter,
-                                    obs=obs)
+                                expt_idx=expt_counter,
+                                obs=obs)
             
-    def model_normalized(self,parameters):
+    def model_normalized(self, parameters):
         """
-        Model output where each experiment is normalized to its experimental
-        mean, standard deviation, and number of experimental points. This 
-        is useful for regression because each point contributes the same amount
-        to the regression. 
-        
-        Parameters
-        ----------
-        parameters : np.ndarray
-            array of parameter values corresponding to the parameters in 
-            self.parameter_names
-        
-        Returns
-        -------
-        y_calc_norm : np.ndarray
-            array of outputs calculated across conditions. pairs with 
-            self.y_obs_normalized and and self.y_std_normalized
-
-        Note
-        ----
-        This should be regressed against self.y_obs_normalized and 
-        self.y_std_normalized, *not* self.y_obs and self.y_std. The resulting 
-        parameter estimates should then reproduce self.y_obs if passed back into
-        self.model. 
+        Model output where each experiment is normalized...
+        ... (docstring unchanged) ...
         """
-
-        # Run model un-normalized (which updates self._y_calc)
         y_calc = self.model(parameters)
-
-        # Now normalize y_calc_norm
         y_calc_norm = (y_calc - self._y_norm_mean)/self._y_norm_std
-
-        # Return
         return y_calc_norm
 
     def model(self,parameters):
         """
         Model output. Can be used to draw plots or as the target of a regression
         analysis against y_obs. 
-
-        Parameters
-        ----------
-        parameters : np.ndarray
-            array of parameter values corresponding to the parameters in 
-            self.parameter_names
-        
-        Returns
-        -------
-        y_calc : np.ndarray
-            array of outputs calculated across conditions. pairs with self.y_obs
-            and self.y_std
+        ... (docstring unchanged) ...
         """
-
-        # Grab binding parameters from guesses. 
         start = self._bm_param_start_idx
         end = self._bm_param_end_idx+1
     
-        # For each experiment, update the macro_arrays (which might change due
-        # to a fudge factor) and then update micro_arrays (which might change 
-        # due to change in macro_array and/or changes in model parameters)
         for i in range(len(self._macro_arrays)):
-
-            # Figure if/how to fudge one of the macro array concentrations
             if self._fudge_list[i] is None:
-                fudge_species_index = 0
                 fudge_value = 1.0
             else:
                 fudge_species_index = self._fudge_list[i][0]
                 fudge_value = parameters[self._fudge_list[i][1]]
             
-            # Get reference macro array without any fudge factor
             self._macro_arrays[i] = self._ref_macro_arrays[i].copy()
+            if self._fudge_list[i] is not None:
+                self._macro_arrays[i][:,fudge_species_index] *= fudge_value
 
-            # Fudge the macro array
-            self._macro_arrays[i][:,fudge_species_index] *= fudge_value
-
-            # Update del_macro_array
             self._del_macro_arrays[i] = self._expt_syringe_concs[i] - self._macro_arrays[i]
 
-            # For each titration step in this experiment (row of concs in 
-            # marco_arrays[i]), update _micro_arrays[i] with the binding model
             for j in range(len(self._macro_arrays[i])):
-
                 self._micro_arrays[i][j,:] = self._bm.get_concs(param_array=parameters[start:end],
                                                                 macro_array=self._macro_arrays[i][j,:])
 
-        # For each point, calculate the observable given the estimated microscopic
-        # and macroscopic concentrations
         y_calc = np.ones(len(self._points))*np.nan
         for i in range(len(self._points)):
             y_calc[i] = self._points[i].calc_value(parameters)
 
         return y_calc
 
+    def jacobian_normalized(self, parameters):
+        """
+        Calculate the Jacobian of the normalized model output with respect to
+        all fittable parameters. This is d(y_calc_normalized)/d(parameters).
+        This callable is suitable for use with scipy.optimize.least_squares.
+        Parameters
+        ----------
+        parameters : np.ndarray
+            Array of all current parameter values.
+        Returns
+        -------
+        J : np.ndarray
+            The Jacobian matrix of shape (num_observations, num_parameters).
+        """
+
+        # ++++++++++++++++++++++++++++++ START OF FIX ++++++++++++++++++++++++++++++
+        # This function MUST NOT raise an exception. If it fails for any reason
+        # (e.g., a numerical error from a bad guess), it should return a NaN matrix.
+        # This allows the sampler's test call to succeed and lets the sampler
+        # reject the bad step instead of crashing.
+        try:
+            # Run the model once to populate all concentration arrays consistently.
+            self.model(parameters)
+
+            num_obs = len(self._points)
+            num_params = len(self.parameter_names)
+            J = np.zeros((num_obs, num_params))
+
+            # Build a list of Jacobians, one for each point, in a stateless way.
+            start, end = self._bm_param_start_idx, self._bm_param_end_idx + 1
+            bm_param_dict = dict(zip(self._bm.param_names, np.exp(parameters[start:end])))
+
+            d_concs_d_bm_params_list = []
+            for i in range(len(self._expt_list)):
+                exp_jacobians = []
+                for j in range(len(self._macro_arrays[i])):
+                    
+                    current_concs_dict = bm_param_dict.copy()
+                    macro_concs = dict(zip(self._bm.macro_species, self._macro_arrays[i][j,:]))
+                    current_concs_dict.update(macro_concs)
+                    micro_concs = dict(zip(self._bm.micro_species, self._micro_arrays[i][j,:]))
+                    current_concs_dict.update(micro_concs)
+                    
+                    if np.isnan(micro_concs[self._bm._c_species_name]):
+                        jac = np.full((len(self._bm.micro_species), len(self._bm.param_names)), np.nan)
+                    else:
+                        jac = self._bm.get_numerical_jacobian(current_concs_dict)
+
+                    if jac is None:
+                        jac = np.full((len(self._bm.micro_species), len(self._bm.param_names)), np.nan)
+                    
+                    exp_jacobians.append(jac)
+                d_concs_d_bm_params_list.append(exp_jacobians)
+
+            for point_idx, pt in enumerate(self._points):
+                expt_idx, shot_idx = pt.expt_idx, pt.idx
+                d_concs_after_d_bm = d_concs_d_bm_params_list[expt_idx][shot_idx]
+
+                if isinstance(pt, SpecPoint):
+                    d_y_d_concs = pt.get_d_y_d_concs()
+                    J[point_idx, start:end] = d_y_d_concs @ d_concs_after_d_bm
+                
+                elif isinstance(pt, ITCPoint) and pt.idx > 0:
+                    d_concs_before_d_bm = d_concs_d_bm_params_list[expt_idx][shot_idx - 1]
+                    d_heat_d_bm = np.zeros(len(self._bm.param_names))
+                    dh_array = parameters[pt._dh_first:pt._dh_last]
+                    
+                    for i in range(len(pt._dh_product_mask)):
+                        mask = pt._dh_product_mask[i]
+                        d_C_after_d_bm = d_concs_after_d_bm[mask, :]
+                        d_C_before_d_bm = d_concs_before_d_bm[mask, :]
+                        d_del_C_d_bm = d_C_after_d_bm - d_C_before_d_bm * pt._meas_vol_dilution
+                        d_dC_d_bm = np.mean(d_del_C_d_bm, axis=0)
+                        d_heat_d_bm += dh_array[i] * pt._dh_sign[i] * d_dC_d_bm
+                    
+                    J[point_idx, start:end] = d_heat_d_bm * pt._total_volume
+
+                other_param_derivs = pt.get_d_y_d_other_params(parameters)
+                for param_idx, deriv_val in other_param_derivs.items():
+                    J[point_idx, param_idx] = deriv_val
+
+                if self._fudge_list[expt_idx] is not None:
+                    pass 
+
+            J[:, start:end] *= np.exp(parameters[start:end])
+            J_normalized = J / self._y_norm_std[:, np.newaxis]
+            return J_normalized
+
+        except Exception as e:
+            # If any failure occurs, log it and return a NaN matrix of the correct shape.
+            tb_str = traceback.format_exc()
+            warnings.warn(f"Jacobian calculation failed with error: {e}\n{tb_str}")
+            num_obs = len(self._points)
+            num_params = len(self.parameter_names)
+            return np.full((num_obs, num_params), np.nan)
+        # +++++++++++++++++++++++++++++++ END OF FIX +++++++++++++++++++++++++++++++
+
+
     @property
     def y_obs(self):
-        """
-        Vector of observed values.
-        """
         return self._y_obs
 
     @property
     def y_std(self):
-        """
-        Vector of standard deviations of observed values.
-        """
         return self._y_std
 
     @property
     def y_obs_normalized(self):
-        """
-        Vector of observed values where each experiment is normalized by
-        (obs - mean(obs))/std(obs). Pairs with y_calc_normalized and 
-        y_std_normalized.
-        """
         return self._y_obs_normalized
     
     @property
     def y_std_normalized(self):
-        """
-        Vector of standard deviations of observed values normalized by 
-        (y_std*expt_std_scalar)/std(obs). Pairs with y_obs_normalized. 
-        """
         return self._y_std_normalized
 
     @property
     def parameter_names(self):
-        """
-        Names of all fit parameters, in stable order.
-        """
         return self._parameter_names
             
     @property
     def parameter_guesses(self):
-        """
-        Parameter values from last run of the model.
-        """
         return self._parameter_guesses
     
     @property
     def model_name(self):
-        """
-        Name of the underlying linkage model used in the analysis.
-        """
         return self._model_name
     
     @property
     def macro_species(self):
-        """
-        Names of all macrospecies, in stable order expected by the linkage 
-        model. 
-        """
         return self._bm.macro_species
     
     @property
     def micro_species(self):
-        """
-        Names of all microspecies, in stable order expected by the linkage 
-        model. 
-        """
         return self._bm.micro_species
     
+    @property
+    def final_ct(self):
+        if self._model_name == "GenericBindingModel":
+            return self._bm.final_ct
+        return None
+    
+    @property
+    def model_spec(self):
+        if self._model_name == "GenericBindingModel":
+            return self._model_spec
+        return None
+    
+    @property
+    def simplified_equations(self):
+        if self._model_name == "GenericBindingModel":
+            return self._bm.simplified_eqs
+        return None
+    
+    @property
+    def solved_vars(self):
+        if self._model_name == "GenericBindingModel":
+            return self._bm.solved_vars
+        return None
+    
     @property
     def as_df(self):
-
-        out = {"expt_id":[],
-               "expt_type":[],
-               "expt_obs":[],
-               "volume":[],
-               "injection":[]}
-
-        for k in self._bm.macro_species:
-            out[k] = []
-
-        for k in self._bm.micro_species:
-            out[k] = []
+        out = {"expt_id":[],"expt_type":[],"expt_obs":[],"volume":[],"injection":[]}
+        for k in self._bm.macro_species: out[k] = []
+        for k in self._bm.micro_species: out[k] = []
 
         for p in self._points:
-            
             out["expt_id"].append(p.expt_idx)
-
-            if issubclass(type(p),SpecPoint):
+            if isinstance(p, SpecPoint):
                 out["expt_type"].append(p.obs_key)
-
-                num = "+".join(self._bm.micro_species[p._obs_mask])
+                num = "+".join([s for s_idx, s in enumerate(self._bm.micro_species) if p._obs_mask[s_idx]])
                 den = self._bm.macro_species[p._denom]
                 out["expt_obs"].append(f"{num}/{den}")
-            
-            elif issubclass(type(p),ITCPoint):
+            elif isinstance(p, ITCPoint):
                 out["expt_type"].append("itc")
-
                 out["expt_obs"].append("obs_heat")
-
             else:
-                err = "point class not recognized\n"
-                raise ValueError(err)
+                raise ValueError("point class not recognized\n")
 
             out["volume"].append(p._total_volume)
             out["injection"].append(p._injection_volume)
-
             for i, k in enumerate(self._bm.macro_species):
                 out[k].append(p._macro_array[p._idx,i])
-
             for i, k in enumerate(self._bm.micro_species):
                 out[k].append(p._micro_array[p._idx,i])
             
@@ -681,4 +637,6 @@ def as_df(self):
 
         return pd.DataFrame(out)
 
-        
\ No newline at end of file
+    @property
+    def concentrations_df(self):
+        return self._bm.concentrations_df
\ No newline at end of file
diff --git a/src/linkage/global_model/point/itc_point.py b/src/linkage/global_model/point/itc_point.py
index 4298e83..ecdd569 100644
--- a/src/linkage/global_model/point/itc_point.py
+++ b/src/linkage/global_model/point/itc_point.py
@@ -1,4 +1,3 @@
-
 from linkage.global_model.point.experimental_point import ExperimentalPoint
 
 import numpy as np
@@ -100,6 +99,8 @@ def calc_value(self,parameters,*args,**kwargs):
         parameters : np.ndarray (float)
             fit parameters (guesses array)
         """
+        if self._idx == 0:
+            return 0.0
 
         dh_array = parameters[self._dh_first:self._dh_last]
         
@@ -134,4 +135,54 @@ def calc_value(self,parameters,*args,**kwargs):
         molar_change = self._del_macro_array[self._idx,self._dh_dilution_mask]
         total_heat += np.sum(dil_heats*molar_change)*self._injection_volume
         
-        return total_heat
\ No newline at end of file
+        return total_heat
+    
+    def get_d_y_d_concs(self):
+        """
+        Returns a placeholder for d(heat)/d(micro_concs).
+
+        The actual logic for this derivative is complex as it depends on both
+        the current and previous concentration states (C_after and C_before).
+        This is handled directly in the `GlobalModel.jacobian_normalized`
+        method for simplicity and to avoid passing many parameters.
+        """
+        return np.zeros(self._micro_array.shape[1], dtype=float)
+
+    def get_d_y_d_other_params(self, parameters):
+        """
+        Calculate the derivative of the heat with respect to any "other"
+        parameters, which for ITC are the enthalpies and heats of dilution.
+
+        Returns
+        -------
+        dict
+            A dictionary where keys are parameter *indices* and values are
+            their derivatives.
+        """
+        deriv_dict = {}
+        if self._idx == 0:
+            return deriv_dict
+
+        # 1. Derivatives with respect to reaction enthalpies (dH_params)
+        for i in range(len(self._dh_product_mask)):
+            param_index = self._dh_first + i
+            # d(heat)/d(dH_i) = V * sign_i * mean(C_after - C_before*dil)
+            
+            C_before = self._micro_array[self._idx - 1, self._dh_product_mask[i]]
+            C_after  = self._micro_array[self._idx, self._dh_product_mask[i]]
+            del_C = C_after - C_before * self._meas_vol_dilution
+            dC = np.mean(del_C)
+            
+            deriv_val = self._total_volume * self._dh_sign[i] * dC
+            deriv_dict[param_index] = deriv_val
+
+        # 2. Derivatives with respect to heats of dilution (dil_params)
+        molar_change = self._del_macro_array[self._idx, self._dh_dilution_mask]
+        dil_param_indices = np.arange(self._dil_first, self._dil_last)
+        
+        for i, param_index in enumerate(dil_param_indices):
+            # d(heat)/d(dil_heat_i) = V_inj * molar_change_i
+            deriv_val = self._injection_volume * molar_change[i]
+            deriv_dict[param_index] = deriv_val
+
+        return deriv_dict
\ No newline at end of file
diff --git a/src/linkage/global_model/point/spec_point.py b/src/linkage/global_model/point/spec_point.py
index 436c2e2..8a55b6b 100644
--- a/src/linkage/global_model/point/spec_point.py
+++ b/src/linkage/global_model/point/spec_point.py
@@ -1,4 +1,3 @@
-
 from .experimental_point import ExperimentalPoint
 
 import numpy as np
@@ -73,6 +72,44 @@ def calc_value(self,*args,**kwargs):
         num = np.sum(self._micro_array[self._idx,self._obs_mask])
         den = self._macro_array[self._idx,self._denom]
 
+        if den == 0:
+            return np.nan
         return num/den
+    
+    def get_d_y_d_concs(self):
+        """
+        Calculate the derivative of the calculated value with respect to the
+        microscopic species concentrations: d(y_calc)/d(micro_concs).
 
+        For y = sum(micro_num) / macro_den, the derivative with respect to
+        a specific micro_species[k] is 1/macro_den if k is in the numerator
+        mask, and 0 otherwise.
+
+        Returns
+        -------
+        numpy.ndarray
+            A 1D array of shape (num_micro_species,).
+        """
+        den = self._macro_array[self._idx, self._denom]
+        if den == 0:
+            return np.zeros(self._micro_array.shape[1], dtype=float)
+            
+        # The derivative is 1/den for species in the numerator, 0 for all others.
+        deriv = self._obs_mask.astype(float) / den
+        return deriv
 
+    def get_d_y_d_other_params(self, parameters):
+        """
+        Calculate the derivative of the calculated value with respect to any
+        "other" parameters (i.e., not binding constants). For SpecPoint,
+        this is essentially zero as fudge factors are handled implicitly.
+
+        Returns
+        -------
+        dict
+            An empty dictionary, as there are no direct parameter dependencies.
+        """
+        # Spectroscopic points have no direct dependence on enthalpies or fudges.
+        # The effect of fudge factors is implicitly captured by the chain rule
+        # in the main GlobalModel jacobian method, via the d(concs)/d(fudge) term.
+        return {}
\ No newline at end of file
diff --git a/src/linkage/model_specs/6state_reparam_test.txt b/src/linkage/model_specs/6state_reparam_test.txt
new file mode 100644
index 0000000..cf091e7
--- /dev/null
+++ b/src/linkage/model_specs/6state_reparam_test.txt
@@ -0,0 +1,17 @@
+equilibria:
+    C + E->EC; KE
+    A -> I; KI
+    A + C -> AC1; K1
+    AC1 + C -> AC2; K2
+    AC2 + C -> AC3; K3
+    AC3 + C -> AC4; K4
+
+species:
+    ET = E + EC
+    AT = I + A + 2*AC1 + AC2 + 2*AC3 + AC4
+    CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4
+
+reparameterize:
+    K2 = K1 * HA_K_ratio
+    K4 = K3 * LA_K_ratio
+	
\ No newline at end of file
diff --git a/src/linkage/model_specs/CaEDTA.txt b/src/linkage/model_specs/CaEDTA.txt
new file mode 100644
index 0000000..19fc844
--- /dev/null
+++ b/src/linkage/model_specs/CaEDTA.txt
@@ -0,0 +1,6 @@
+equilibria:
+    E + C -> EC; KE
+
+species:
+    CT = C + EC
+    ET = E + EC
\ No newline at end of file
diff --git a/src/linkage/model_specs/README.txt b/src/linkage/model_specs/README.txt
new file mode 100644
index 0000000..664c8f2
--- /dev/null
+++ b/src/linkage/model_specs/README.txt
@@ -0,0 +1,29 @@
+README file for the generic binding model implementation.
+
+The generic binding model processes a .txt file of the following format:
+
+equilibria:
+    C + E->EC; KE
+    A -> I; KI
+    A + C -> AC1; K1
+    AC1 + C -> AC2; K2
+    AC2 + C -> AC3; K3
+    AC3 + C -> AC4; K4
+
+species:
+    ET = E + EC
+    AT = I + A + 2*AC1 + AC2 + 2*AC3 + AC4
+    CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4
+
+In it's current implementation, the generic model will attempt using a sympy algorithm to solve for C in terms of CT and
+other macrospecies concentrations (i.e. ET, CT) and the equilibrium constants defined to the right of the semicolon in the 
+equilibria portion of the .txt file. It is also possible to assign a python string within the .ipynb file as the model, 
+which may be useful for on-the-fly modifications. 
+
+Two important considerations:
+-Not all equilibria/species models are able to be converted into a functional binding polynomial, and it is worth checking 
+a simple implementation of your model by hand (i.e. with degeneracy of 1 for each microspecies)
+-The rational equation final_ct that the generic model produces is generally slower to iterate than a hand-written polynomial. 
+If computation is a limiting factor, it may be worth writing out the rational equation (accessible via gm._bm.print_summary() for
+an instantiation of global model called gm) and manipulating it into a polynomial equation. Even if this is the case, much of the
+algebraic legwork will be done already.
diff --git a/src/linkage/model_specs/SixStateEDTA+TMAO.txt b/src/linkage/model_specs/SixStateEDTA+TMAO.txt
new file mode 100644
index 0000000..d441e09
--- /dev/null
+++ b/src/linkage/model_specs/SixStateEDTA+TMAO.txt
@@ -0,0 +1,14 @@
+equilibria:
+    C + E->EC; KE
+    A + M -> I; KM
+    I -> A; KI
+    A + C -> AC1; K1
+    AC1 + C -> AC2; K2
+    AC2 + C -> AC3; K3
+    AC3 + C -> AC4; K4
+
+species:
+    MT = M
+    ET = E + EC
+    AT = I + A + 2*AC1 + AC2 + 2*AC3 + AC4
+    CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4
\ No newline at end of file
diff --git a/src/linkage/model_specs/SixStateEDTA.txt b/src/linkage/model_specs/SixStateEDTA.txt
new file mode 100644
index 0000000..33940ad
--- /dev/null
+++ b/src/linkage/model_specs/SixStateEDTA.txt
@@ -0,0 +1,12 @@
+equilibria:
+    C + E->EC; KE
+    A -> I; KI
+    A + C -> AC1; K1
+    AC1 + C -> AC2; K2
+    AC2 + C -> AC3; K3
+    AC3 + C -> AC4; K4
+
+species:
+    ET = E + EC
+    AT = I + A + 2*AC1 + AC2 + 2*AC3 + AC4
+    CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4
\ No newline at end of file
diff --git a/src/linkage/model_specs/hA4_8Cycle.txt b/src/linkage/model_specs/hA4_8Cycle.txt
new file mode 100644
index 0000000..a116817
--- /dev/null
+++ b/src/linkage/model_specs/hA4_8Cycle.txt
@@ -0,0 +1,16 @@
+equilibria:
+    E + C -> EC; KE
+    A + C -> AC1; K1
+    AC1 + C -> AC2; K2
+    AC2 + C -> AC3; K3
+    AC3 + C -> AC4; K4
+    I + C -> IC1; KI1
+    IC1 + C -> IC2; KI2
+    A -> I; KT1
+    AC1 -> IC1; KT2
+    AC2 -> IC2; KT3
+
+species:
+    ET = E + EC
+    AT = I + 2*IC1 + IC2 + A + 2*AC1 + AC2 + 2*AC3 + AC4
+    CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4 + 2*IC1 + 2*IC2
diff --git a/src/linkage/models/__init__.py b/src/linkage/models/__init__.py
index 9e812f0..09e407d 100644
--- a/src/linkage/models/__init__.py
+++ b/src/linkage/models/__init__.py
@@ -1,3 +1,6 @@
-
 from linkage.models.six_state_edta import SixStateEDTA
 from linkage.models.ca_edta import CaEDTA
+from linkage.models.six_state_test import SixStateEDTATest
+from linkage.models.eight_cycle_a4 import EightCycleA4
+from linkage.models.ca_edta_test import CaEDTATest
+from linkage.models.generic_binding_model import GenericBindingModel
\ No newline at end of file
diff --git a/src/linkage/models/ca_edta_test.py b/src/linkage/models/ca_edta_test.py
new file mode 100644
index 0000000..83e256c
--- /dev/null
+++ b/src/linkage/models/ca_edta_test.py
@@ -0,0 +1,103 @@
+from linkage.models.base import BindingModel
+import numpy as np
+import warnings
+
+
+class CaEDTATest(BindingModel):
+    """
+    equilibria:
+        E + C -> EC; KE
+
+    species:
+        ET = E + EC
+        CT = C + EC
+    """
+
+    def get_concs(self, param_array, macro_array):
+        """
+        Get the concentrations of all species in solution given the model
+        parameters and concentrations of macro species.
+
+        Parameters
+        ----------
+        param_array : numpy.ndarray
+            array of equilibrium constant (KE)
+        macro_array : numpy.ndarray
+            array of total concentrations (C_total, E_total)
+
+        Returns
+        -------
+        concs : numpy.ndarray
+            array of species concentrations (C, E, EC)
+        """
+        # Apply exponential transform with scaling
+        exp_params = np.exp(param_array)
+        k_scale = max(1.0, np.max(exp_params))  # Prevent downscaling
+        print(f"Original KE: {exp_params[0]}, Scaled KE: {exp_params[0]/k_scale}")
+        KE = exp_params[0] / k_scale
+        
+        CT, ET = macro_array
+        
+        # Scale concentrations with minimum scale
+        conc_scale = max(1e-6, max(CT, ET))  # Set minimum scale
+        if conc_scale > 0:
+            CT, ET = CT/conc_scale, ET/conc_scale
+
+        # Early return for boundary cases
+        if CT == 0 or ET == 0:
+            return np.array([CT, ET, 0.0], dtype=float)
+
+        # Simple quadratic in EC
+        a = 1
+        b = -(CT + ET + 1 / KE)
+        c = ET * CT
+
+        try:
+            s = np.sqrt(b**2 - 4 * a * c)
+            if not np.isfinite(s):
+                raise ValueError("Non-finite discriminant in quadratic solution")
+            
+            roots = np.array([(-b + s) / (2 * a), (-b - s) / (2 * a)])
+            
+            # EC is the real root between 0->ET and 0->CT
+            EC = self._get_real_root(roots=roots, upper_bounds=[ET, CT])
+            
+            if not np.isfinite(EC):
+                raise ValueError("Non-finite root found")
+
+            # Get species
+            C = CT - EC
+            E = ET - EC
+            
+            # Check results are physical
+            if not (0 <= EC <= min(ET, CT)):
+                raise ValueError(f"EC={EC} outside valid range [0, min({ET}, {CT})]")
+            if not (0 <= C <= CT):
+                raise ValueError(f"C={C} outside valid range [0, {CT}]")
+            if not (0 <= E <= ET):
+                raise ValueError(f"E={E} outside valid range [0, {ET}]")
+
+            # Rescale concentrations back
+            concentrations = np.array([C, E, EC], dtype=float)
+            return concentrations * conc_scale
+
+        except Exception as e:
+            # Provide diagnostic information
+            w = f"\nQuadratic solution failed: {str(e)}\n"
+            w += f"Parameters: KE={KE:.2e}\n"
+            w += f"Concentrations: CT={CT:.2e}, ET={ET:.2e}\n"
+            w += f"Coefficients: a={a:.2e}, b={b:.2e}, c={c:.2e}\n"
+            warnings.warn(w)
+            raise
+
+    @property
+    def param_names(self):
+        return np.array(["KE"])
+
+    @property
+    def macro_species(self):
+        return np.array(["CT", "ET"])
+
+    @property
+    def micro_species(self):
+        return np.array(["C", "E", "EC"])
\ No newline at end of file
diff --git a/src/linkage/models/eight_cycle_a4.py b/src/linkage/models/eight_cycle_a4.py
new file mode 100644
index 0000000..86f773b
--- /dev/null
+++ b/src/linkage/models/eight_cycle_a4.py
@@ -0,0 +1,134 @@
+"""
+"""
+
+from linkage.models.base import BindingModel
+import numpy as np
+from scipy.optimize import fsolve
+
+
+class EightCycleA4(BindingModel):
+    
+    '''
+    equilibria:
+        E + C -> EC; KE
+        A + C -> AC1; K1
+        AC1 + C -> AC2; K2
+        AC2 + C -> AC3; K3
+        AC3 + C -> AC4; K4
+        I + C -> IC1; KI1
+        IC1 + C -> IC2; KI2
+        A -> I; KT1
+        AC1 -> IC1; KT2
+        AC2 -> IC2; KT3
+
+    species:
+        ET = E + EC
+        AT = I + 2*IC1 + IC2 + A + 2*AC1 + AC2 + 2*AC3 + AC4
+        CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4 + 2*IC1 + 2*IC2
+    ''' 
+
+    def _get_free_c(self, KE, K1, K2, K3, K4, KI1, KI2, KT1, KT2, KT3, AT, CT, ET):
+
+        def equation(C):
+
+            return (4*AT*C**4*K1*K2*K3*K4/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1) 
+                    + 6*AT*C**3*K1*K2*K3/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1)
+                    + 2*AT*C**2*K1*K2*KT3/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1)
+                    + 2*AT*C**2*K1*K2/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1)
+                    + 2*AT*C*K1*KT2/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1)
+                    + 2*AT*C*K1/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1)
+                    + C*ET*KE/(C*KE + 1) + C)
+
+        try:
+            # Initial guess
+            C0 = CT / 2
+
+            # Solve the equation
+            result = fsolve(equation, C0, full_output=True)
+
+            if result[2] != 1:  # Check if solution was found
+                print("Failed to find solution")
+                return np.nan
+
+            root = result[0][0]  # First element of solution array
+
+            # Check if root is physical (between 0 and CT)
+            if not (0 <= root <= CT) or not np.isfinite(root):
+                return np.nan
+
+            return root
+
+        except Exception as e:
+            print(f"Error in root finding: {e}")
+            return np.nan
+
+    def get_concs(self, param_array, macro_array):
+        """
+        Get the concentrations of all species in solution given the model parameters
+        and concentrations of macro species.
+
+        Parameters
+        ----------
+        param_array : numpy.ndarray
+            array of five equilibrium constants (KI, KE, K1, K2, K3, K4)
+            Note: Values are in log space but named to match equilibria notation
+        macro_array : numpy.ndarray
+            array of total concentrations (A_total, C_total, E_total)
+
+        Returns
+        -------
+        concs : numpy.ndarray
+            array of species concentrations (A_free, C_free, E_free, AC1, AC2,
+            AC3, AC4, EC).
+        """
+        # Check parameters for valid values
+        if np.any(np.isnan(param_array)):
+            return np.full(11, 0)
+
+        if not np.all(np.isfinite(param_array)):
+            return np.full(11, 0)
+
+        if np.any(param_array == 0):
+            return np.full(11, 0)
+
+        KE, K1, K2, K3, K4, KI1, KI2, KT1, KT2, KT3 = np.exp(param_array)
+
+        AT, CT, ET = macro_array
+
+        C = self._get_free_c(
+            KE, K1, K2, K3, K4, KI1, KI2, KT1, KT2, KT3, AT, CT, ET
+        )
+
+        # Is C a NaN
+        if not np.isfinite(C):
+            return np.full(11, 0)   
+
+        # Microspecies equations
+        E = ET/(C*KE + 1)
+        A = AT/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2*KT3 + C**2*K1*K2 + 2*C*K1*KT2 + 2*C*K1 + KT1 + 1)
+        AC1 = A*C*K1
+        AC2 = AC1*C*K2
+        AC3 = AC2*C*K3
+        AC4 = AC3*C*K4
+        EC = C*E*KE
+        I = KT1*A
+        IC1 = KT2*AC1
+        IC2 = KT3*AC2
+
+        return np.array([A, C, E, AC1, AC2, AC3, AC4, EC, I, IC1, IC2])
+
+    @property
+    def param_names(self):
+        return np.array(
+            ["KE", "K1", "K2", "K3", "K4", "KI1", "KI2", "KT1", "KT2", "KT3"]
+        )
+
+    @property
+    def macro_species(self):
+        return np.array(["AT", "CT", "ET"])
+
+    @property
+    def micro_species(self):
+        return np.array(
+            ["A", "C", "E", "AC1", "AC2", "AC3", "AC4", "EC", "I", "IC1", "IC2"]
+        )
diff --git a/src/linkage/models/generic_binding_model.py b/src/linkage/models/generic_binding_model.py
new file mode 100644
index 0000000..aca19a3
--- /dev/null
+++ b/src/linkage/models/generic_binding_model.py
@@ -0,0 +1,311 @@
+import numpy as np
+import pandas as pd
+from sympy import Poly, lambdify, diff, Matrix
+import warnings
+from bindingpolytools import BindingPolynomial
+
+
+class GenericBindingModel():
+
+
+    def __init__(self, model_spec, debug=False):
+
+
+        """
+        Solves for species concentrations in a system of chemical equilibrium.
+
+        This class uses the `BindingPolynomial` class from the `BindingPolyTools`
+        library, which uses the SymPy library to symbolically derive the binding
+        polynomial equation from a set of user-defined equilibrium and mass
+        conservation equations. This derived polynomial is then used to perform
+        fast numerical calculations, solving for the concentrations of all chemical
+        species under specified conditions.
+
+        The core methodology relies on algebraically reducing the entire system of
+        equilibria and mass balance equations into a single polynomial for one
+        unknown free concentration (referred to internally as `_c_symbol`). Once the
+        root of this polynomial is found numerically, all other species'
+        concentrations are determined by back-substitution.
+
+        Analytical Jacobian Calculation:
+        -------------------------------
+        In addition to solving for concentrations, the class performs a one-time
+        symbolic derivation of the Jacobian matrix. This matrix represents the
+        sensitivity of each species' concentration to changes in the equilibrium
+        constants (i.e., d[species]/d[K]).
+
+        The derivation uses SymPy to apply the Implicit Function Theorem and the
+        chain rule to the symbolic equations. The resulting analytical Jacobian is
+        then compiled into a highly efficient numerical function. This provides a
+        significant speed and accuracy advantage over traditional numerical
+        differentiation (e.g., finite difference) methods. The numerical Jacobian
+        can be retrieved for any set of conditions, making it ideal for use in
+        sensitivity analysis or gradient-based optimization for parameter fitting.
+
+        Model Specification and Limitations:
+        -----------------------------------
+        Formatting examples for the `model_spec` input can be found in the
+        `linkage/src/linkage/model_specs` folder. 
+        The specification can also be defined as a docstring
+        in a script or Jupyter notebook for on-the-fly model changes.
+
+        The `model_spec` string must define a system whose species dependency
+        graph is acyclic. This technical constraint means that the network of
+        reactions can be solved through sequential substitution, which is a
+        requirement for the symbolic engine to derive the necessary polynomial.
+
+        In less mathematical terms, the model's structure must not contain any
+        circular dependencies.
+
+        Examples of supported reaction topologies:
+        - Sequential Binding: A linear chain of reactions, such as a protein
+            binding multiple ligands in a stepwise fashion (e.g., P -> PL -> PL2).
+        - Competitive Binding: A central hub species binding to multiple,
+            non-interacting competitors (e.g., L1 <- P -> L2). This forms a valid
+            star-shaped or tree-like structure.
+
+        Examples of unsupported (cyclic) topologies that will fail:
+        - Reaction Rings: A system where species A binds B, B binds C, and C
+            in turn binds A. It is impossible to solve for [A] without first
+            knowing [C], which requires knowing [B], which requires knowing [A],
+            creating a circular dependency.
+        - Coupled Systems: Any system that cannot be algebraically simplified
+            and would require a numerical solver for a system of simultaneous
+            non-linear equations.
+        """
+
+
+        if model_spec is None:
+            raise ValueError("No model specification provided")
+
+        self._model_spec = model_spec
+        self._debug = debug
+
+        poly_tool = BindingPolynomial(model_spec, debug=self._debug)
+
+        self._equilibria = poly_tool._equilibria
+        self._constants = poly_tool._constants
+        self._micro_species = poly_tool._micro_species
+        self._macro_species = poly_tool._macro_species
+
+        self.symbols_dict = poly_tool.symbols
+        self._c_symbol = poly_tool._c_symbol
+        self._c_species_name = poly_tool._c_species_name
+        self._ct_macrospecies_name = poly_tool._ct_macrospecies_name
+
+        self.simplified_eqs = poly_tool.simplified_eqs
+        self.solved_vars = poly_tool.solved_vars
+        
+        # Renamed for consistency with the GlobalModel API
+        self.final_ct = poly_tool.binding_polynomial 
+        
+        self._setup_numerical_model()
+        
+        # Perform one-time symbolic derivation of the Jacobian
+        self._setup_symbolic_jacobian()
+        
+        self._concentrations_df = pd.DataFrame(columns=self._micro_species, dtype=float)
+        self._last_concs_dict = None # For Jacobian calculation
+    
+    def _log(self, message):
+        if self._debug:
+            print(message)
+
+    def _setup_numerical_model(self):
+        self._log("\nPreparing symbolic model for numerical evaluation")
+
+        try:
+            self.poly_obj = Poly(self.final_ct, self._c_symbol)
+            self.symbolic_coeffs = self.poly_obj.all_coeffs()
+
+            self._param_symbols_ordered = sorted(
+                [s for s in self.final_ct.free_symbols if s != self._c_symbol], 
+                key=lambda s: s.name
+            )
+
+            self._lambdified_coeffs_funcs = []
+            for coeff_expr in self.symbolic_coeffs:
+                args_for_lambdify = [s for s in self._param_symbols_ordered if s in coeff_expr.free_symbols]
+
+                if not args_for_lambdify:
+                    self._lambdified_coeffs_funcs.append(lambda **kwargs: float(coeff_expr))
+                else:
+                    self._lambdified_coeffs_funcs.append(lambdify(args_for_lambdify, coeff_expr, "numpy"))
+
+            self._log(f"Successfully lambdified {len(self.symbolic_coeffs)} polynomial coefficients.")
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to process the symbolic polynomial and lambdify its coefficients. Error: {e}")
+
+    def _setup_symbolic_jacobian(self):
+        """
+        Derives a symbolic Jacobian d(micro_species)/d(constants) once using
+        SymPy and the Implicit Function Theorem, then lambdifies it into a
+        fast numerical function.
+        """
+        self._log("\nDeriving symbolic Jacobian")
+        self.jacobian_function = None
+        self._jacobian_input_symbols = None
+
+        try:
+            F = self.final_ct
+            param_symbols = [self.symbols_dict[c] for c in self._constants]
+
+            # 1. Calculate partial derivatives of the polynomial F(c, params)
+            dF_dc = diff(F, self._c_symbol)
+            dF_dparams = [diff(F, p) for p in param_symbols]
+
+            # 2. Apply Implicit Function Theorem: dc/dp = -(dF/dp) / (dF/dc)
+            dc_dparams = [-dF_dp / dF_dc for dF_dp in dF_dparams]
+
+            # 3. Build the full Jacobian matrix using the chain rule
+            jacobian_rows = []
+            for species_name in self._micro_species:
+                species_sym = self.symbols_dict[species_name]
+
+                # Find the symbolic expression for the current species
+                if species_sym == self._c_symbol:
+                    species_expr = self._c_symbol
+                elif species_sym in self.solved_vars:
+                    species_expr = self.solved_vars[species_sym]
+                elif species_sym in self.simplified_eqs:
+                    species_expr = self.simplified_eqs[species_sym]
+                else: 
+                    raise ValueError(f"Cannot find symbolic expression for {species_name}")
+
+                row = []
+                for i, param_sym in enumerate(param_symbols):
+                    # Total derivative: d(species)/d(param) = (∂S/∂c)*(dc/dp) + (∂S/∂p)_direct
+                    chain_rule_part = diff(species_expr, self._c_symbol) * dc_dparams[i]
+                    direct_part = diff(species_expr, param_sym)
+                    total_deriv = chain_rule_part + direct_part
+                    row.append(total_deriv)
+                jacobian_rows.append(row)
+
+            symbolic_jacobian = Matrix(jacobian_rows)
+            
+            # 4. Lambdify the symbolic matrix for fast numerical evaluation
+            self._jacobian_input_symbols = sorted(list(symbolic_jacobian.free_symbols), key=lambda s: s.name)
+            self.jacobian_function = lambdify(self._jacobian_input_symbols, symbolic_jacobian, "numpy")
+            self._log(f"Successfully created lambdified Jacobian function.")
+
+        except Exception as e:
+            self.jacobian_function = None
+            self._jacobian_input_symbols = None
+            warnings.warn(f"Failed to derive symbolic Jacobian. Falling back to numerical methods. Error: {e}")
+
+    def get_numerical_jacobian(self, concs_dict):
+        """
+        Calculates the numerical Jacobian d(micro_species)/d(constants) at a
+        specific point in concentration space.
+
+        Parameters
+        ----------
+        concs_dict : dict
+            A dictionary of all current species concentrations and parameter values.
+            Keys must be strings (e.g., "K1", "P", "L", "PL").
+
+        Returns
+        -------
+        numpy.ndarray
+            The numerical Jacobian matrix, or None if the symbolic function is not available.
+        """
+        if self.jacobian_function is None:
+            return None
+        
+        try:
+            # Prepare arguments for the lambdified function in the correct order
+            args = [concs_dict[s.name] for s in self._jacobian_input_symbols]
+            return self.jacobian_function(*args)
+        except Exception as e:
+            self._log(f"Failed to evaluate numerical Jacobian: {e}")
+            return None
+
+    def _get_free_c(self, **param_dict_num_values):
+        CT_val = param_dict_num_values.get(self._ct_macrospecies_name)
+        if CT_val == 0:
+            return 0.0
+
+        numerical_coeffs = []
+        for i, lamb_func in enumerate(self._lambdified_coeffs_funcs):
+            sym_coeff = self.symbolic_coeffs[i]
+            arg_names = [s.name for s in self._param_symbols_ordered if s in sym_coeff.free_symbols]
+            kwargs_for_func = {name: param_dict_num_values[name] for name in arg_names}
+            numerical_coeffs.append(lamb_func(**kwargs_for_func))
+        
+        coeffs_for_polyroots = [float(c) for c in reversed(numerical_coeffs)]
+        
+        try:
+            roots = np.polynomial.polynomial.polyroots(coeffs_for_polyroots)
+            return self._get_real_root(roots, upper_bounds=[CT_val])
+        except Exception as e:
+            self._log(f"numpy.polyroots failed: {e}")
+            return np.nan
+
+    def get_concs(self, param_array, macro_array):
+        param_dict = dict(zip(self._constants, np.exp(param_array)))
+        param_dict.update(dict(zip(self._macro_species, macro_array)))
+        
+        C_free_val = self._get_free_c(**param_dict)
+        if np.isnan(C_free_val):
+            self._last_concs_dict = None
+            return np.full(len(self._micro_species), np.nan)
+
+        concs_dict = {self._c_species_name: C_free_val}
+        
+        subs_dict = {self.symbols_dict[name]: val for name, val in param_dict.items()}
+        subs_dict[self._c_symbol] = C_free_val
+
+        for base_var_sym, expr in self.solved_vars.items():
+            val = float(expr.subs(subs_dict))
+            concs_dict[base_var_sym.name] = val
+            subs_dict[base_var_sym] = val
+
+        for complex_sym, expr in self.simplified_eqs.items():
+            val = float(expr.subs(subs_dict))
+            concs_dict[complex_sym.name] = val
+            
+        # Store the current state for the Jacobian calculation
+        self._last_concs_dict = {**param_dict, **concs_dict}
+
+        # Record concentrations to internal dataframe
+        df_row = pd.DataFrame([concs_dict], columns=self._micro_species)
+        self._concentrations_df = pd.concat([self._concentrations_df, df_row], ignore_index=True)
+
+        return np.array([concs_dict.get(name, 0.0) for name in self._micro_species])
+
+    def _get_real_root(self, roots_complex, upper_bounds=[]):
+        real_roots = np.real(roots_complex[np.isreal(roots_complex)])
+        positive_roots = real_roots[real_roots >= -1e-14]
+        positive_roots[positive_roots < 0] = 0
+
+        if len(positive_roots) == 0: return np.nan
+        
+        valid_roots = positive_roots
+        if upper_bounds:
+            min_upper_bound = np.min(upper_bounds)
+            valid_roots = valid_roots[valid_roots <= min_upper_bound * 1.001]
+
+        if len(valid_roots) == 0: return np.nan
+
+        return np.min(valid_roots)
+    
+    @property
+    def equilibria(self):
+        return self._equilibria
+    
+    @property
+    def param_names(self):
+        return np.array(self._constants)
+    
+    @property
+    def macro_species(self):
+        return np.array(self._macro_species)
+    
+    @property
+    def micro_species(self):
+        return np.array(self._micro_species)
+
+    @property
+    def concentrations_df(self):
+        return self._concentrations_df
\ No newline at end of file
diff --git a/src/linkage/models/six_state_edta.py b/src/linkage/models/six_state_edta.py
index 2e27d4c..29cf533 100644
--- a/src/linkage/models/six_state_edta.py
+++ b/src/linkage/models/six_state_edta.py
@@ -74,7 +74,7 @@ def get_concs(self,param_array,macro_array):
             AC3, AC4, EC).
         """
 
-        KI, KE, K1, K2, K3, K4 = param_array
+        KI, KE, K1, K2, K3, K4 = np.exp(param_array)
         AT, CT, ET = macro_array
         
         # Get the free calcium concentration
diff --git a/src/linkage/models/six_state_test.py b/src/linkage/models/six_state_test.py
new file mode 100644
index 0000000..3c279dc
--- /dev/null
+++ b/src/linkage/models/six_state_test.py
@@ -0,0 +1,122 @@
+"""
+"""
+
+from linkage.models.base import BindingModel
+import numpy as np
+from scipy.optimize import fsolve
+
+
+class SixStateEDTATest(BindingModel):
+    """
+    equilibria:
+        E + C -> EC; KE
+        A -> I; KI
+        A + C -> AC1; K1
+        AC1 + C -> AC2; K2
+        AC2 + C -> AC3; K3
+        AC3 + C -> AC4; K4
+
+    species:
+        ET = E + EC
+        AT = I + A + 2*AC1 + AC2 + 2*AC3 + AC4
+        CT = C + EC + 2*AC1 + 2*AC2 + 6*AC3 + 4*AC4
+    """
+
+    def _get_free_c(self, KI, KE, K1, K2, K3, K4, AT, CT, ET):
+        def equation(C):
+            return (4*AT*C**4*K1*K2*K3*K4/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI + 1)
+                    + 6*AT*C**3*K1*K2*K3/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI + 1)
+                    + 2*AT*C**2*K1*K2/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI + 1)
+                    + 2*AT*C*K1/(C**4*K1*K2*K3*K4 + 2*C**3*K1*K2*K3 + C**2*K1*K2 + 2*C*K1 + KI + 1)
+                    + C*ET*KE/(C*KE + 1) + C
+                    - CT)
+
+        try:
+            # Initial guess
+            C0 = CT / 2
+
+            # Solve the equation
+            result = fsolve(equation, C0, full_output=True)
+
+            if result[2] != 1:  # Check if solution was found
+            #     print("Failed to find solution")
+                return np.nan
+
+            root = result[0][0]  # First element of solution array
+            # Check if root is physical (between 0 and CT)
+            if not (0 <= root <= CT) or not np.isfinite(root):
+                return np.nan
+
+            return root
+
+        except Exception as e:
+            print(f"Error in root finding: {e}")
+            return np.nan
+
+    def get_concs(self, param_array, macro_array):
+        """
+        Get the concentrations of all species in solution given the model parameters
+        and concentrations of macro species.
+
+        Parameters
+        ----------
+        param_array : numpy.ndarray
+            array of five equilibrium constants (KI, KE, K1, K2, K3, K4)
+            Note: Values are in log space but named to match equilibria notation
+        macro_array : numpy.ndarray
+            array of total concentrations (A_total, C_total, E_total)
+
+        Returns
+        -------
+        concs : numpy.ndarray
+            array of species concentrations (A_free, C_free, E_free, AC1, AC2,
+            AC3, AC4, EC).
+        """
+        KI, KE, K1, K2, K3, K4 = np.exp(param_array)
+        AT, CT, ET = macro_array
+    
+        C = self._get_free_c(KI, KE, K1, K2, K3, K4, AT, CT, ET)
+
+        # Add this check
+        if not np.isfinite(C):
+            return np.full(9, 0)
+
+        # Rest of concentration calculations 
+        C1 = C
+        C2 = C**2
+        C3 = C**3
+        C4 = C**4
+
+        den = (
+            1
+            + KI
+            + 2 * K1 * C1
+            + K1 * K2 * C2
+            + 2 * K1 * K2 * K3 * C3
+            + K1 * K2 * K3 * K4 * C4
+        )
+        A = AT / den
+
+        den = 1 + KE * C
+        E = ET / den
+
+        I = KI * A
+        EC = KE * E * C
+        AC1 = K1 * A * C
+        AC2 = AC1 * K2 * C
+        AC3 = AC2 * K3 * C
+        AC4 = AC3 * K4 * C
+
+        return np.array([I, A, C, E, AC1, AC2, AC3, AC4, EC])
+
+    @property
+    def param_names(self):
+        return np.array(["KI", "KE", "K1", "K2", "K3", "K4"])
+
+    @property
+    def macro_species(self):
+        return np.array(["AT", "CT", "ET"])
+
+    @property
+    def micro_species(self):
+        return np.array(["I", "A", "C", "E", "AC1", "AC2", "AC3", "AC4", "EC"])
\ No newline at end of file