DiadFit 0.0.85__py3-none-any.whl → 0.0.88__py3-none-any.whl

DiadFit/error_propagation.py

@@ -3,68 +3,15 @@ import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 import DiadFit as pf
-
+from tqdm import tqdm
 from DiadFit.density_depth_crustal_profiles import *
 from DiadFit.CO2_EOS import *
+# This gets us the functions for Monte Carloing
+from DiadFit.CO2_in_bubble_error import *
 
 ## Microthermometry error propagation
-# propagate_microthermometry_uncertainty_1sam goes to 'make_error_dist_microthermometry_1sam'
-
-def make_error_dist_microthermometry_1sam(*, T_h_C, sample_i=0, error_T_h_C=0.3, N_dup=1000,
-        error_dist_T_h_C='uniform', error_type_T_h_C='Abs', len_loop=1):
-    
-    """ 
-
-    This function generates a dataset of temperature measurements for a given sample. 
-    It adds random noise to the temperature measurement based on the specified distribution and error type.
-
-    Parameters
-    ----------
-    T_h_C : numeric or list of numeric values
-        The measured temperature(s) of the sample(s) in degrees Celsius.
-    sample_i : int, optional
-        The index of the sample for which the error distribution will be generated. Default value is 0.
-    error_T_h_C : numeric, optional
-        The amount of error to add to the temperature measurement. Default value is 0.3.
-    N_dup : int, optional
-        The number of duplicated samples to generate with random noise. Default value is 1000.
-    error_dist_T_h_C : str, optional
-        The distribution of the random noise to be added to the temperature measurement. Can be either 'normal' or 'uniform'. Default value is 'uniform'.
-    error_type_T_h_C : str, optional
-        The type of error to add to the temperature measurement. Can be either 'Abs' or 'Perc'. Default value is 'Abs'.
-    len_loop : int, optional
-        The number of samples for which the error distribution will be generated. Default value is 1.
 
-    Returns
-    -------
-    numpy.ndarray
-        An array of temperature measurements with random noise added to them based on the specified error 
-        distribution and error type. The size of the array is (N_dup, len(T_h_C)).
 
-    """
-
-    if len_loop==1:
-        df_c=pd.DataFrame(data={'T_h_C': T_h_C}, index=[0])
-    else:
-        df_c=pd.DataFrame(data={'T_h_C': T_h_C})
-
-
-    # Temperature error distribution
-    if error_type_T_h_C=='Abs':
-        error_T_h_C=error_T_h_C
-    if error_type_T_h_C =='Perc':
-        error_T_h_C=df_c['T_h_C'].iloc[sample_i]*error_T_h_C/100
-    if error_dist_T_h_C=='normal':
-        Noise_to_add_T_h_C = np.random.normal(0, error_T_h_C, N_dup)
-    if error_dist_T_h_C=='uniform':
-        Noise_to_add_T_h_C = np.random.uniform(- error_T_h_C, +
-                                                      error_T_h_C, N_dup)
-    
-    T_h_C_with_noise=Noise_to_add_T_h_C+df_c['T_h_C'].iloc[0]
-    
-    
-
-    return T_h_C_with_noise
 
 
 def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0.3, N_dup=1000,
@@ -136,26 +83,20 @@ def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0
 
 
     All_outputs=pd.DataFrame([])
-    Std_density_gas=np.empty(len_loop)
-    Std_density_liq=np.empty(len_loop)
-    Mean_density_gas=np.empty(len_loop)
-    Mean_density_liq=np.empty(len_loop)
-    Std_density_gas_IQR=np.empty(len_loop)
-    Std_density_Liq_IQR=np.empty(len_loop)
-    Sample=np.empty(len_loop,  dtype=np.dtype('U100') )
+    Std_density_gas=np.zeros(len_loop)
+    Std_density_liq=np.zeros(len_loop)
+    Mean_density_gas=np.zeros(len_loop)
+    Mean_density_liq=np.zeros(len_loop)
+    Std_density_gas_IQR=np.zeros(len_loop)
+    Std_density_Liq_IQR=np.zeros(len_loop)
+    Sample=np.zeros(len_loop,  dtype=np.dtype('U100') )
 
     for i in range(0, len_loop):
 
         # If user has entered a pandas series for error, takes right one for each loop
-        if type(error_T_h_C) is pd.Series:
-            error_T_h_C=error_T_h_C.iloc[i]
-        else:
-            error_T_h_C=error_T_h_C
+        error_T_h_C_i=get_value(error_T_h_C, i)
+        T_h_C_i=get_value(T_h_C, i)
 
-        if type(T_h_C) is pd.Series:
-            T_h_C_i=T_h_C.iloc[i]
-        else:
-            T_h_C_i=T_h_C
 
         # Check of
         if Sample_ID is None:
@@ -166,9 +107,8 @@ def propagate_microthermometry_uncertainty(T_h_C, Sample_ID=None,  error_T_h_C=0
         else:
             Sample[i]=Sample_ID.iloc[i]
 
-        Temp_MC=make_error_dist_microthermometry_1sam(T_h_C=T_h_C_i,
-        sample_i=i, error_T_h_C=error_T_h_C, N_dup=N_dup,
-        error_dist_T_h_C=error_dist_T_h_C, error_type_T_h_C=error_type_T_h_C, len_loop=1)
+        Temp_MC= add_noise_to_variable(T_h_C, error_T_h_C,
+        error_type_T_h_C, error_dist_T_h_C, N_dup, True, neg_threshold=0.0000000001)
 
         Sample2=Sample[i]
         MC_T=calculate_CO2_density_homog_T(T_h_C=Temp_MC, Sample_ID=Sample2, EOS=EOS, homog_to=homog_to, set_to_critical=set_to_critical)
@@ -217,7 +157,7 @@ CO2_dens_gcm3=None, error_CO2_dens=0, error_type_CO2_dens='Abs', error_dist_CO2_
  T_K=None, error_T_K=0, error_type_T_K='Abs', error_dist_T_K='normal',
 crust_dens_kgm3=None, error_crust_dens=0, error_type_crust_dens='Abs', error_dist_crust_dens='normal', XH2O=None,
 error_XH2O=None, error_type_XH2O='Abs', error_dist_XH2O='normal',
- model=None):
+ model=None, neg_values=True):
 
     """
     This function generates the range of T_K, CO2 densities, XH2O and crustal densities for 1 sample 
@@ -290,12 +230,12 @@ error_XH2O=None, error_type_XH2O='Abs', error_dist_XH2O='normal',
         if isinstance(T_K, pd.Series) or isinstance(CO2_dens_gcm3, pd.Series) or isinstance(T_K, np.ndarray) or isinstance(CO2_dens_gcm3, np.ndarray):
             df_c=pd.DataFrame(data={'T_K': T_K,
                                 'CO2_dens_gcm3': CO2_dens_gcm3,
-                                'XH2O': 0})
+                                'XH2O': None})
         else:
             #print('here')
             df_c=pd.DataFrame(data={'T_K': T_K,
                                 'CO2_dens_gcm3': CO2_dens_gcm3,
-                                'XH2O': 0}, index=[0])
+                                'XH2O': None}, index=[0])
     # IF have XH2O add here
     else:
         if isinstance(T_K, pd.Series) or isinstance(CO2_dens_gcm3, pd.Series) or isinstance(T_K, np.ndarray) or isinstance(CO2_dens_gcm3, np.ndarray) or isinstance(XH2O, np.ndarray):
@@ -312,77 +252,32 @@ error_XH2O=None, error_type_XH2O='Abs', error_dist_XH2O='normal',
 
         
     # Temperature error distribution
-    if error_type_T_K=='Abs':
-        error_T_K=error_T_K
-    if error_type_T_K =='Perc':
-        error_T_K=df_c['T_K'].iloc[sample_i]*error_T_K/100
-    if error_dist_T_K=='normal':
-        Noise_to_add_T_K = np.random.normal(0, error_T_K, N_dup)
-    if error_dist_T_K=='uniform':
-        Noise_to_add_T_K = np.random.uniform(- error_T_K, +
-                                                      error_T_K, N_dup)
-
-    
-    T_K_with_noise=Noise_to_add_T_K+df_c['T_K'].iloc[sample_i]
-    T_K_with_noise[T_K_with_noise < 0.0001] = 0.0001
-
-
+    T_K_with_noise=add_noise_to_variable(T_K, error_T_K,
+        error_type_T_K, error_dist_T_K,  N_dup, neg_values, neg_threshold=0.0000000001)
+        
     # CO2 error distribution
+    CO2_dens_with_noise=add_noise_to_variable(CO2_dens_gcm3, error_CO2_dens,
+        error_type_CO2_dens, error_dist_CO2_dens,  N_dup, neg_values, neg_threshold=0.0000000001)
+
 
-    if error_type_CO2_dens=='Abs':
-        error_CO2_dens=error_CO2_dens
-    if error_type_CO2_dens =='Perc':
-        error_CO2_dens=df_c['CO2_dens_gcm3'].iloc[sample_i]*error_CO2_dens/100
-    if error_dist_CO2_dens=='normal':
-        Noise_to_add_CO2_dens = np.random.normal(0, error_CO2_dens, N_dup)
-    if error_dist_CO2_dens=='uniform':
-        Noise_to_add_CO2_dens = np.random.uniform(- error_CO2_dens, +
-                                                      error_CO2_dens, N_dup)
-
-    CO2_dens_with_noise=Noise_to_add_CO2_dens+df_c['CO2_dens_gcm3'].iloc[sample_i]
-    CO2_dens_with_noise[CO2_dens_with_noise < 0.0001] = 0.0001
     
     # XH2O error distribution (if relevant)
     if XH2O is not None:
-        if error_type_XH2O=='Abs':
-            error_XH2O=error_XH2O
-        if error_type_XH2O =='Perc':
-            error_XH2O=df_c['XH2O'].iloc[sample_i]*error_XH2O/100
-        if error_dist_XH2O=='normal':
-            Noise_to_add_XH2O = np.random.normal(0, error_XH2O, N_dup)
-        if error_dist_XH2O=='uniform':
-            Noise_to_add_XH2O = np.random.uniform(- error_XH2O, +
-                                                        error_XH2O, N_dup)
-    
-        XH2O_with_noise=Noise_to_add_XH2O+df_c['XH2O'].iloc[sample_i]
+        XH2O_with_noise=add_noise_to_variable(XH2O, error_XH2O,
+        error_type_XH2O, error_dist_XH2O,  N_dup, True, neg_threshold=0.0000000000)
         XH2O_with_noise[XH2O_with_noise < 0.000000] = 0.00000
         XH2O_with_noise[XH2O_with_noise > 1] = 1
-
         
-            
-    
+        
+        
     
-
     # Crustal density noise
     # First need to work out what crustal density is
 
     if type(crust_dens_kgm3) is float or type(crust_dens_kgm3) is int:
-        # This is the simplicest scenario, just makes a distribution of pressures
-
-        if error_type_crust_dens=='Abs':
-            error_crust_dens=error_crust_dens
-        if error_type_crust_dens =='Perc':
-            error_crust_dens=crust_dens_kgm3*error_crust_dens/100
-        if error_dist_crust_dens=='normal':
-            Noise_to_add_crust_dens = np.random.normal(0, error_crust_dens, N_dup)
-        if error_dist_crust_dens=='uniform':
-            Noise_to_add_crust_dens = np.random.uniform(- error_crust_dens, +
-                                                        error_crust_dens, N_dup)
-
-
-
-        crust_dens_with_noise=Noise_to_add_crust_dens+crust_dens_kgm3
-        crust_dens_with_noise[crust_dens_with_noise < 0.0001] = 0.0001
+        crust_dens_with_noise=add_noise_to_variable(crust_dens_kgm3, error_crust_dens_kgm3,
+        error_type_crust_dens, error_dist_crust_dens,  N_dup, neg_values, neg_threshold=0.0000000001)
+        
 
     elif model is not None:
         crust_dens_with_noise=None
@@ -416,12 +311,6 @@ error_XH2O=None, error_type_XH2O='Abs', error_dist_XH2O='normal',
         df_out['XH2O_with_noise']=XH2O_with_noise
         df_out['error_type_XH2O']=error_type_XH2O
         df_out['error_dist_XH2O']=error_dist_XH2O
-    else:
-        df_out['error_XH2O']=0
-        df_out['XH2O_with_noise']=0
-
-        
-
 
 
 
@@ -438,6 +327,23 @@ error_CO2_dens=0, error_type_CO2_dens='Abs', error_dist_CO2_dens='normal',
 
     print('Please use the new function propagate_FI_uncertainty instead as this allows you use different EOS')
 
+# Check for panda Series
+
+def convert_inputs_to_series(T_K, error_T_K, CO2_dens_gcm3, error_CO2_dens_gcm3, XH2O, error_XH2O):
+    # Create a list of all inputs
+    inputs = [T_K, error_T_K, CO2_dens_gcm3, error_CO2_dens_gcm3, XH2O, error_XH2O]
+    
+    # Convert any numpy arrays in the inputs to pandas Series
+    converted_inputs = [pd.Series(item) if isinstance(item, np.ndarray) else item for item in inputs]
+    
+    # Unpack the converted inputs back to their respective variables
+    T_K, error_T_K, CO2_dens_gcm3, error_CO2_dens_gcm3, XH2O, error_XH2O = converted_inputs
+    
+    # Continue with the function using the possibly converted inputs...
+    # For demonstration, just return the converted inputs
+    return T_K, error_T_K, CO2_dens_gcm3, error_CO2_dens_gcm3, XH2O, error_XH2O
+    
+    
 
 
 def propagate_FI_uncertainty(sample_ID, CO2_dens_gcm3, T_K,  N_dup=1000, EOS='SW96', 
@@ -448,7 +354,7 @@ error_CO2_dens=0, error_type_CO2_dens='Abs', error_dist_CO2_dens='normal',
  model=None, d1=None, d2=None, rho1=None, rho2=None, rho3=None,
 error_T_K=0, error_type_T_K='Abs', error_dist_T_K='normal',
 XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=True,
-
+neg_values=True
 ):
 
     """
@@ -499,7 +405,7 @@ XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=
 
 
 
-    X_H2O: pd.Series, integer, float
+    XH2O: Default Nan, else pd.Series, integer, float
         mol proportion of H2O in the fluid phase
     error_XH2O: float
         Error in XH2O
@@ -548,7 +454,9 @@ XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=
 
     
 
-
+    neg_values: bool (default True)
+        if True, negative values of input parameters  allowed, if False, makes neg values zero. 
+        
     Returns
     ----------------
 
@@ -565,12 +473,19 @@ XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=
 
 
     """
+    # Check for non pandas series as inputs 
+    T_K, error_T_K, CO2_dens_gcm3, error_CO2_dens, XH2O, error_XH2O = convert_inputs_to_series(
+        T_K, error_T_K, CO2_dens_gcm3, error_CO2_dens, XH2O, error_XH2O)
+    
+    
     if XH2O is not None:
         print('You have entered a value for XH2O, so we are now using the EOS of Duan and Zhang 2006. If you dont want this, specify XH2O=None')
         print('Please note, the DZ2006 EOS is about 5-40X slower to run than the SP94 and SW94 EOS')
+        
     if isinstance(T_K, float) or isinstance(T_K, int) :
         if pd.isna(T_K):
             raise TypeError("Your Input Temperature is NaN - We cant do EOS calculatoins")
+            
     elif isinstance(T_K, pd.Series):
             if T_K.isna().any():
                 raise TypeError("At least one of your Input Temperature is NaN - We cant do EOS calculatoins")
@@ -578,33 +493,30 @@ XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=
     if isinstance(crust_dens_kgm3, str):
         raise TypeError('Do not enter a string for crustal density, put it as a model instead')
 
-    # Set up empty things to fill up.
 
     if type(CO2_dens_gcm3) is pd.Series:
         len_loop=len(CO2_dens_gcm3)
     else:
         len_loop=1
         
-    
-
-
+    # Setting up empty arrays filled with zeros 
 
-    SingleCalc_D_km = np.empty(len_loop, dtype=float)
-    SingleCalc_Press_kbar = np.empty(len_loop, dtype=float)
+    SingleCalc_D_km = np.zeros(len_loop, dtype=float)
+    SingleCalc_Press_kbar = np.zeros(len_loop, dtype=float)
 
-    mean_Press_kbar = np.empty(len_loop, dtype=float)
-    med_Press_kbar = np.empty(len_loop, dtype=float)
-    std_Press_kbar = np.empty(len_loop, dtype=float)
-    std_Press_kbar_IQR=np.empty(len_loop, dtype=float)
+    mean_Press_kbar = np.zeros(len_loop, dtype=float)
+    med_Press_kbar = np.zeros(len_loop, dtype=float)
+    std_Press_kbar = np.zeros(len_loop, dtype=float)
+    std_Press_kbar_IQR=np.zeros(len_loop, dtype=float)
 
-    mean_D_km = np.empty(len_loop, dtype=float)
-    med_D_km = np.empty(len_loop, dtype=float)
-    std_D_km = np.empty(len_loop, dtype=float)
-    std_D_km_IQR=np.empty(len_loop, dtype=float)
-    CO2_density_input=np.empty(len_loop, dtype=float)
-    error_crust_dens_loop=np.empty(len_loop, dtype=float)
-    error_crust_dens2_loop=np.empty(len_loop, dtype=float)
-    Sample=np.empty(len_loop,  dtype=np.dtype('U100') )
+    mean_D_km = np.zeros(len_loop, dtype=float)
+    med_D_km = np.zeros(len_loop, dtype=float)
+    std_D_km = np.zeros(len_loop, dtype=float)
+    std_D_km_IQR=np.zeros(len_loop, dtype=float)
+    CO2_density_input=np.zeros(len_loop, dtype=float)
+    error_crust_dens_loop=np.zeros(len_loop, dtype=float)
+    error_crust_dens2_loop=np.zeros(len_loop, dtype=float)
+    Sample=np.zeros(len_loop,  dtype=np.dtype('U100') )
 
     All_outputs=pd.DataFrame([])
 
@@ -619,82 +531,79 @@ XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=
 
 
     #This loops through each fluid inclusion entered density
-    for i in range(0, len_loop):
-        if i % 20 == 0:
-            print('working on sample number '+str(i))
+    
 
+    for i in tqdm(range(0, len_loop), desc="Processing"):
+
+        
+        # This fills in the columns for the single calculation, e.g. no Monte-Carloing from above. 
         SingleCalc_D_km[i]=df_ind['Depth (km)'].iloc[i]
         SingleCalc_Press_kbar[i]=df_ind['Pressure (kbar)'].iloc[i]
-
-
-        # If user has entered a pandas series for error, takes right one for each loop
-        if type(error_T_K) is pd.Series:
-            error_T_K=error_T_K.iloc[i]
-        else:
-            error_T_K=error_T_K
-
-        if type(T_K) is pd.Series:
-            T_K_i=T_K.iloc[i]
-        else:
-            T_K_i=T_K
-
-
-        if type(CO2_dens_gcm3) is pd.Series:
-            CO2_dens_gcm3_i=CO2_dens_gcm3.iloc[i]
-        else:
-            CO2_dens_gcm3_i=CO2_dens_gcm3
-
-
-        if type(error_CO2_dens) is pd.Series:
-            error_CO2_dens=error_CO2_dens.iloc[i]
-        else:
-            error_CO2_dens=error_CO2_dens
-            
+        
+        # Now lets get the value, using the function in the CO2_in_bubble_error.py file
+        error_T_K_i=get_value(error_T_K, i)
+        T_K_i=get_value(T_K, i)
+        
+        CO2_dens_gcm3_i=get_value(CO2_dens_gcm3, i)
+        error_CO2_dens_i=get_value(error_CO2_dens, i)
+        
+        crust_dens_kgm3_i=get_value(crust_dens_kgm3, i)
+        error_crust_dens_i=get_value(error_crust_dens, i)
+        # Now, if XH2O was entered, and isnt None, do the same. Else keeps as None. 
         if XH2O is not None:
-            if type(error_XH2O) is pd.Series:
-                error_XH2O=error_XH2O.iloc[i]
-            else:
-                error_XH2O=error_XH2O
-
-        if type(error_crust_dens) is pd.Series:
-            error_crust_dens=error_crust_dens.iloc[i]
-        else:
-            error_crust_dens=error_crust_dens
-            
+            error_XH2O_i=get_value(error_XH2O, i)
+            XH2O_i=get_value(XH2O, i)
         
 
 
         # This is the function doing the work to actually make the simulations for each variable.
+        # For each input variable, it makes a distribution. 
+        
+        # If XH2O is None, it doesnt return the column XH2O_with_noise, which helps ID this later. 
         if XH2O is None:
-            df_synthetic=calculate_temperature_density_MC(sample_i=i, N_dup=N_dup, CO2_dens_gcm3=CO2_dens_gcm3,
-        T_K=T_K, error_T_K=error_T_K, error_type_T_K=error_type_T_K, error_dist_T_K=error_dist_T_K,
-        error_CO2_dens=error_CO2_dens, error_type_CO2_dens=error_type_CO2_dens, error_dist_CO2_dens=error_dist_CO2_dens,
-        crust_dens_kgm3=crust_dens_kgm3,  error_crust_dens=error_crust_dens, error_type_crust_dens= error_type_crust_dens, error_dist_crust_dens=error_dist_crust_dens,
-    model=model)
+            
+            df_synthetic=calculate_temperature_density_MC(N_dup=N_dup, CO2_dens_gcm3=CO2_dens_gcm3_i,
+        T_K=T_K_i, error_T_K=error_T_K_i, error_type_T_K=error_type_T_K, error_dist_T_K=error_dist_T_K,
+        error_CO2_dens=error_CO2_dens_i, error_type_CO2_dens=error_type_CO2_dens, error_dist_CO2_dens=error_dist_CO2_dens,
+        crust_dens_kgm3=crust_dens_kgm3_i,  error_crust_dens=error_crust_dens_i, error_type_crust_dens= error_type_crust_dens, error_dist_crust_dens=error_dist_crust_dens,
+    model=model, neg_values=neg_values)
+    
+            if model is None:
+                MC_T=convert_co2_dens_press_depth(T_K=df_synthetic['T_K_with_noise'],
+                                                CO2_dens_gcm3=df_synthetic['CO2_dens_with_noise'],
+                                            crust_dens_kgm3=df_synthetic['crust_dens_with_noise'],
+                                            d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3,model=model,
+                                                EOS=EOS )
+            else:
+                MC_T=convert_co2_dens_press_depth(T_K=df_synthetic['T_K_with_noise'],
+                                                CO2_dens_gcm3=df_synthetic['CO2_dens_with_noise'],
+                                                d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3,
+                                            model=model, EOS=EOS)
     
         if XH2O is not None:
-            df_synthetic=calculate_temperature_density_MC(sample_i=i, N_dup=N_dup, CO2_dens_gcm3=CO2_dens_gcm3,
-        T_K=T_K, error_T_K=error_T_K, error_type_T_K=error_type_T_K, error_dist_T_K=error_dist_T_K,
-        error_CO2_dens=error_CO2_dens, error_type_CO2_dens=error_type_CO2_dens, error_dist_CO2_dens=error_dist_CO2_dens,
-        crust_dens_kgm3=crust_dens_kgm3,  error_crust_dens=error_crust_dens, error_type_crust_dens= error_type_crust_dens, error_dist_crust_dens=error_dist_crust_dens,
-    model=model, XH2O=XH2O, error_XH2O=error_XH2O, error_type_XH2O=error_type_XH2O, error_dist_XH2O=error_dist_XH2O)
+            
+            df_synthetic=calculate_temperature_density_MC(N_dup=N_dup, CO2_dens_gcm3=CO2_dens_gcm3_i,
+        T_K=T_K_i, error_T_K=error_T_K_i, error_type_T_K=error_type_T_K, error_dist_T_K=error_dist_T_K,
+        error_CO2_dens=error_CO2_dens_i, error_type_CO2_dens=error_type_CO2_dens, error_dist_CO2_dens=error_dist_CO2_dens,
+        crust_dens_kgm3=crust_dens_kgm3_i,  error_crust_dens=error_crust_dens_i, error_type_crust_dens= error_type_crust_dens, error_dist_crust_dens=error_dist_crust_dens,
+    model=model, XH2O=XH2O_i, error_XH2O=error_XH2O_i, error_type_XH2O=error_type_XH2O, error_dist_XH2O=error_dist_XH2O,  neg_values=neg_values)
             
 
         # Convert to densities for MC
 
-        if model is None:
-            MC_T=convert_co2_dens_press_depth(T_K=df_synthetic['T_K_with_noise'],
-                                            CO2_dens_gcm3=df_synthetic['CO2_dens_with_noise'],
-                                        crust_dens_kgm3=df_synthetic['crust_dens_with_noise'],
-                                        XH2O=df_synthetic['XH2O_with_noise'], Hloss=Hloss,
-                                        d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3,model=model,
-                                            EOS=EOS,  )
-        else:
-            MC_T=convert_co2_dens_press_depth(T_K=df_synthetic['T_K_with_noise'],
-                                            CO2_dens_gcm3=df_synthetic['CO2_dens_with_noise'],
-                                           XH2O=df_synthetic['XH2O_with_noise'], Hloss=Hloss,
-                                            d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3,
-                                        model=model, EOS=EOS)
+            if model is None:
+                MC_T=convert_co2_dens_press_depth(T_K=df_synthetic['T_K_with_noise'],
+                                                CO2_dens_gcm3=df_synthetic['CO2_dens_with_noise'],
+                                            crust_dens_kgm3=df_synthetic['crust_dens_with_noise'],
+                                            XH2O=df_synthetic['XH2O_with_noise'], Hloss=Hloss,
+                                            d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3,model=model,
+                                                EOS=EOS )
+            else:
+                MC_T=convert_co2_dens_press_depth(T_K=df_synthetic['T_K_with_noise'],
+                                                CO2_dens_gcm3=df_synthetic['CO2_dens_with_noise'],
+                                            XH2O=df_synthetic['XH2O_with_noise'], Hloss=Hloss,
+                                                d1=d1, d2=d2, rho1=rho1, rho2=rho2, rho3=rho3,
+                                            model=model, EOS=EOS)
 
 
 
@@ -750,7 +659,6 @@ XH2O=None, error_XH2O=0, error_type_XH2O='Abs', error_dist_XH2O='normal', Hloss=
                         'CO2_dens_gcm3': CO2_density_input,
                          'SingleFI_D_km': SingleCalc_D_km,
                          'SingleFI_P_kbar': SingleCalc_Press_kbar,
-
                              'Mean_MC_P_kbar': mean_Press_kbar,
                          'Med_MC_P_kbar': med_Press_kbar,
                             'std_dev_MC_P_kbar': std_Press_kbar,
@@ -916,6 +824,8 @@ def convert_co2_dens_press_depth(EOS='SW96', T_K=None,
 
 
     # First step is to get pressure
+    
+    
     if XH2O is None:
         Pressure=calculate_P_for_rho_T(T_K=T_K,
                     CO2_dens_gcm3=CO2_dens_gcm3,
@@ -949,8 +859,7 @@ def convert_co2_dens_press_depth(EOS='SW96', T_K=None,
                                         'MC_T_K': T_K,
                                         'MC_CO2_dens_gcm3': CO2_dens_gcm3})
     
-        #df.replace([np.inf, -np.inf], np.nan, inplace=True)
-    
+        
                     
         # Make as a dict to allow index=0 if depth is float, else not. 
         data_dict = {
@@ -967,8 +876,10 @@ def convert_co2_dens_press_depth(EOS='SW96', T_K=None,
     
         
     # If XH2O, need different outputs. 
+    
     else:
         
+        
         P_kbar_calc=pf.calculate_entrapment_P_XH2O(XH2O=XH2O, CO2_dens_gcm3=CO2_dens_gcm3, T_K=T_K, T_K_ambient=T_K_ambient, fast_calcs=True, Hloss=Hloss )