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

DiadFit/densimeters.py

@@ -498,8 +498,10 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
        Split_err=(split_err*Split).astype(float)
 
 
-    if temp=='RoomT':
-        raise TypeError('Sorry, this function doesnt yet support the calibration at 24C, please enter temp=SupCrit')
+        
+        
+        
+   
     if isinstance(Split, float) or isinstance(Split, int):
         Split=pd.Series(Split)
     # #if temp is "RoomT":
@@ -509,7 +511,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     HighD_RT=-41.64784 + 0.4058777*Split- 0.1460339*(Split-104.653)**2
 
     # IF temp is 37
-    if lab=='CMASS':
+    if lab=='CMASS' and temp=='SupCrit':
         # This gets the densimeter at low density
         pickle_str_lowr='Lowrho_polyfit_data_CMASS.pkl'
         with open(DiadFit_dir/pickle_str_lowr, 'rb') as f:
@@ -523,6 +525,25 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
         pickle_str_highr='Highrho_polyfit_data_CMASS.pkl'
         with open(DiadFit_dir/pickle_str_highr, 'rb') as f:
             highrho_pickle_data = pickle.load(f)
+            
+            
+    
+            
+    if lab=='CMASS' and temp=='RoomT':
+        # This gets the densimeter at low density
+        pickle_str_lowr='Lowrho_polyfit_data_CMASS_24C.pkl'
+        with open(DiadFit_dir/pickle_str_lowr, 'rb') as f:
+            lowrho_pickle_data = pickle.load(f)
+    
+
+        # This gets the densimeter at high density.
+        pickle_str_highr='Highrho_polyfit_data_CMASS_24C.pkl'
+        with open(DiadFit_dir/pickle_str_highr, 'rb') as f:
+            highrho_pickle_data = pickle.load(f)
+                      
+            
+            
+            
     elif lab=='CCMR':
         pickle_str_lowr='Lowrho_polyfit_data_CCMR.pkl'
         with open(DiadFit_dir/pickle_str_lowr, 'rb') as f:
@@ -543,7 +564,13 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
 
     # this allocates the model
     lowrho_model = lowrho_pickle_data['model']
-    medrho_model = medrho_pickle_data['model']
+    
+    if temp=='SupCrit':
+        medrho_model = medrho_pickle_data['model']
+        MedD_SC = pd.Series(medrho_model(Split), index=Split.index)
+        medD_error=calculate_Densimeter_std_err_values(corrected_split=Split, corrected_split_err=Split_err,
+        pickle_str=pickle_str_medr,  CI_dens=CI_neon, CI_split=CI_split, str_d='MedD')
+        
     highrho_model = highrho_pickle_data['model']
 
     # Each of these lines get the density, and then the error on that density.
@@ -551,10 +578,8 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     LowD_SC = pd.Series(lowrho_model(Split), index=Split.index)
     lowD_error=calculate_Densimeter_std_err_values(corrected_split=Split, corrected_split_err=Split_err,
     pickle_str=pickle_str_lowr,  CI_dens=CI_neon, CI_split=CI_split, str_d='LowD')
+ 
 
-    MedD_SC = pd.Series(medrho_model(Split), index=Split.index)
-    medD_error=calculate_Densimeter_std_err_values(corrected_split=Split, corrected_split_err=Split_err,
-    pickle_str=pickle_str_medr,  CI_dens=CI_neon, CI_split=CI_split, str_d='MedD')
 
     HighD_SC = pd.Series(highrho_model(Split), index=Split.index)
     highD_error=calculate_Densimeter_std_err_values(corrected_split=Split, corrected_split_err=Split_err,
@@ -563,7 +588,14 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
 
 
 
-
+    if temp=='RoomT':
+        MedD_SC=np.nan
+        MedD_err=np.nan
+        
+    else:
+        MedD_err=medD_error['MedD_Density_σ']
+        
+        
     df=pd.DataFrame(data={'Preferred D': 0,
     'Corrected_Splitting': Split,
     'Preferred D_σ': 0,
@@ -578,7 +610,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
                                 'LowD_SC': LowD_SC,
                                 'LowD_SC_σ': lowD_error['LowD_Density_σ'],
                                 'MedD_SC': MedD_SC,
-                                'MedD_SC_σ': medD_error['MedD_Density_σ'],
+                                'MedD_SC_σ': MedD_err,
                                 'HighD_SC': HighD_SC,
                                 'HighD_SC_σ': highD_error['HighD_Density_σ'],
                                 'Temperature': temp,
@@ -594,6 +626,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     # If splitting is 0
     zero=df['Corrected_Splitting']==0
 
+
     # Range for SC low density
     min_lowD_SC_Split=df['Corrected_Splitting']>=102.7623598753032
     max_lowD_SC_Split=df['Corrected_Splitting']<=103.1741034592534
@@ -634,12 +667,13 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     df.loc[ SupCrit&(min_HD_SC_Split&max_HD_SC_Split), 'Preferred D_σ_split'] = highD_error['HighD_Density_σ_split']
     df.loc[ SupCrit&(min_HD_SC_Split&max_HD_SC_Split), 'Preferred D_σ_dens'] = highD_error['HighD_Density_σ_dens']
     df.loc[ SupCrit&(min_HD_SC_Split&max_HD_SC_Split), 'Notes']='SupCrit, high density'
-    # If SupCrit, Med density
-    df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D'] = MedD_SC
-    df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D_σ'] = medD_error['MedD_Density_σ']
-    df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D_σ_split'] = medD_error['MedD_Density_σ_split']
-    df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D_σ_dens'] = medD_error['MedD_Density_σ_dens']
-    df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Notes']='SupCrit, Med density'
+    
+    if temp!='RoomT':
+        df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D'] = MedD_SC
+        df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D_σ'] = medD_error['MedD_Density_σ']
+        df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D_σ_split'] = medD_error['MedD_Density_σ_split']
+        df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Preferred D_σ_dens'] = medD_error['MedD_Density_σ_dens']
+        df.loc[SupCrit&(min_MD_SC_Split&max_MD_SC_Split), 'Notes']='SupCrit, Med density'
 
     # If SupCrit, low density
     df.loc[ SupCrit&(min_lowD_SC_Split&max_lowD_SC_Split), 'Preferred D'] = LowD_SC
@@ -652,6 +686,26 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     df.loc[SupCrit&(Too_Low_SC), 'Preferred D']=LowD_SC
     df.loc[SupCrit&(Too_Low_SC), 'Notes']='Below lower calibration limit'
     df.loc[SupCrit&(Too_Low_SC), 'in range']='N'
+    
+    
+    
+    # now lets do Room T ---------------------------------
+    df.loc[ roomT&(min_HD_SC_Split&max_HD_SC_Split), 'Preferred D'] = HighD_SC
+    df.loc[ roomT&(min_HD_SC_Split&max_HD_SC_Split), 'Preferred D_σ'] = highD_error['HighD_Density_σ']
+    df.loc[ roomT&(min_HD_SC_Split&max_HD_SC_Split), 'Preferred D_σ_split'] = highD_error['HighD_Density_σ_split']
+    df.loc[ roomT&(min_HD_SC_Split&max_HD_SC_Split), 'Preferred D_σ_dens'] = highD_error['HighD_Density_σ_dens']
+    df.loc[ roomT&(min_HD_SC_Split&max_HD_SC_Split), 'Notes']='roomT, high density'
+    
+    # If roomT, low density
+    df.loc[ roomT&(min_lowD_SC_Split&max_lowD_SC_Split), 'Preferred D'] = LowD_SC
+    df.loc[ roomT&(min_lowD_SC_Split&max_lowD_SC_Split), 'Preferred D_σ'] = lowD_error['LowD_Density_σ']
+    df.loc[ roomT&(min_lowD_SC_Split&max_lowD_SC_Split), 'Preferred D_σ_split'] = lowD_error['LowD_Density_σ_split']
+    df.loc[ roomT&(min_lowD_SC_Split&max_lowD_SC_Split), 'Preferred D_σ_dens'] = lowD_error['LowD_Density_σ_dens']
+    df.loc[roomT&(min_lowD_SC_Split&max_lowD_SC_Split), 'Notes']='roomT, low density'    
+    
+    
+    
+    
 
 
     # If RoomT, and too low
@@ -731,21 +785,30 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     
 
 
-    #
-    #
 
-    if Ne_pickle_str is not None:
+    
+    
+    if Ne_pickle_str is not None: # If its not none, have all the columns for Ne
         cols_to_move = ['filename', 'Density g/cm3', 'σ Density g/cm3','σ Density g/cm3 (from Ne+peakfit)', 'σ Density g/cm3 (from densimeter)',
         'Corrected_Splitting', 'Corrected_Splitting_σ',
         'Corrected_Splitting_σ_Ne', 'Corrected_Splitting_σ_peak_fit', 'power (mW)', 'Spectral Center']
         df_merge = df_merge[cols_to_move + [
             col for col in df_merge.columns if col not in cols_to_move]]
-    elif pref_Ne is not None:
+            
+    # If pref Ne is not none and you dont have a dataframe 
+    elif pref_Ne is not None and df_combo is not None: #If Pref Ne, 
         cols_to_move = ['filename', 'Density g/cm3', 'σ Density g/cm3','σ Density g/cm3 (from Ne+peakfit)', 'σ Density g/cm3 (from densimeter)',
         'Corrected_Splitting', 'Corrected_Splitting_σ',
         'Corrected_Splitting_σ_Ne', 'Corrected_Splitting_σ_peak_fit']
         df_merge = df_merge[cols_to_move + [
             col for col in df_merge.columns if col not in cols_to_move]]
+            
+    elif df_combo is None:
+        
+        cols_to_move = ['Density g/cm3', 'σ Density g/cm3','σ Density g/cm3 (from Ne+peakfit)', 'σ Density g/cm3 (from densimeter)',
+        'Corrected_Splitting']
+        df_merge = df_merge[cols_to_move + [
+            col for col in df_merge.columns if col not in cols_to_move]]
 
     
 
@@ -906,7 +969,7 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
 
     Parameters
     -------------
-    Ne_line_combo: str, '1117_1447', '1220_1447', '1220_1400'
+    Ne_line_combo: str, '1117_1447', '1117_1400', '1220_1447', '1220_1400', '1220_1567'
         Combination of Ne lines used for drift correction
         
     Either:
@@ -1042,6 +1105,22 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
         with open(DiadFit_dir/pickle_str_highr, 'rb') as f:
             highrho_pickle_data = pickle.load(f)
             
+            
+    if Ne_line_combo=='1220_1567':
+       
+        pickle_str_lowr='Lowrho_polyfit_dataUCB_1220_1567.pkl'
+        with open(DiadFit_dir/pickle_str_lowr, 'rb') as f:
+            lowrho_pickle_data = pickle.load(f)
+
+        # This gets the densimeter at medium density
+        pickle_str_medr='Mediumrho_polyfit_dataUCB_1220_1567.pkl'
+        with open(DiadFit_dir/pickle_str_medr, 'rb') as f:
+            medrho_pickle_data = pickle.load(f)
+        # This gets the densimeter at high density.
+        pickle_str_highr='Highrho_polyfit_dataUCB_1220_1567.pkl'
+        with open(DiadFit_dir/pickle_str_highr, 'rb') as f:
+            highrho_pickle_data = pickle.load(f)
+            
     if Ne_line_combo=='1117_1400':
         pickle_str_lowr='Lowrho_polyfit_dataUCB_1117_1400.pkl'
         with open(DiadFit_dir/pickle_str_lowr, 'rb') as f:
@@ -1125,29 +1204,30 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
     # If splitting is 0
     zero=df['Corrected_Splitting']==0
 
-    # Range for SC low density
-    min_lowD_SC_Split=df['Corrected_Splitting']>=102.7623598753032
-    max_lowD_SC_Split=df['Corrected_Splitting']<=103.1741034592534
+    
+    offset=0
+    if Ne_line_combo=='1220_1400':
+        offset=105.257-105.3438707618937
+
+    
+        
+    
+        
+        
+    min_lowD_SC_Split=df['Corrected_Splitting']>=102.7623598753032+offset
+    max_lowD_SC_Split=df['Corrected_Splitting']<=103.1741034592534+offset
     # Range for SC med density
-    min_MD_SC_Split=df['Corrected_Splitting']>103.0608505403591
-    max_MD_SC_Split=df['Corrected_Splitting']<=104.3836704771313
+    min_MD_SC_Split=df['Corrected_Splitting']>103.0608505403591+offset
+    max_MD_SC_Split=df['Corrected_Splitting']<=104.3836704771313+offset
     # Range for SC high density
-    min_HD_SC_Split=df['Corrected_Splitting']>=104.2538992302499
-    max_HD_SC_Split=df['Corrected_Splitting']<=105.3438707618937
-    # Range for Room T low density
-    min_lowD_RoomT_Split=df['Corrected_Splitting']>=102.734115670188
-    max_lowD_RoomT_Split=df['Corrected_Splitting']<=103.350311768435
-    # Range for Room T high density
-    min_HD_RoomT_Split=df['Corrected_Splitting']>=104.407308904012
-    max_HD_RoomT_Split=df['Corrected_Splitting']<=105.1
-    # Impossible densities, room T
-    Imposs_lower_end=(df['Corrected_Splitting']>103.350311768435) & (df['Corrected_Splitting']<103.88)
+    min_HD_SC_Split=df['Corrected_Splitting']>=104.2538992302499+offset
+    max_HD_SC_Split=df['Corrected_Splitting']<=105.3438707618937+offset
+    Too_Low_SC=df['Corrected_Splitting']<102.72+offset
+    Too_Low_RT=df['Corrected_Splitting']<102.734115670188+offset
+    
+    Imposs_lower_end=(df['Corrected_Splitting']>103.350311768435+offset) # & (df['Splitting']<103.88+offset)
     # Impossible densities, room T
-    Imposs_upper_end=(df['Corrected_Splitting']<104.407308904012) & (df['Corrected_Splitting']>103.88)
-    # Too low density
-    Too_Low_SC=df['Corrected_Splitting']<102.7623598753032
-    Too_Low_RT=df['Corrected_Splitting']<102.734115670188
-
+    Imposs_upper_end=(df['Corrected_Splitting']<105.3438707618937+offset)# & (df['Splitting']>103.88+offset)  
     df.loc[zero, 'Preferred D']=0
     df.loc[zero, 'Notes']=0
     
@@ -1276,5 +1356,67 @@ CI_split=0.67, CI_neon=0.67,  Ne_pickle_str=None, pref_Ne=None, Ne_err=None, cor
 
 
     return df_merge
+    
+    ## Method from FLuids laboratory from FRANCIS Program
+    
+
+
+def Francis_pureCO2(FDS, FDS_std, uncer_FDS, uncer_FDS_std=0):
+    """ Returns density using a densimeter made from a single CO2 standard
+    """
+    offset= 0.035089020233933815 # Calculated FDS at 0.01 g/cm3
+    FDS_normalized_1=(FDS - FDS_std) + (uncer_FDS**2 + uncer_FDS_std**2)**0.5 + offset
+    FDS_normalized=(FDS - FDS_std)  + offset
+    FDS_normalized_2=(FDS - FDS_std) - (uncer_FDS**2 + uncer_FDS_std**2)**0.5 + offset
+
+    p0= 0
+    p1= 148.73
+    p2= 20.946
+    p3= -180.85
+    p4= 96.503
+    p5= -9.8157
+
+    d0= 0
+    d1= +0.31273
+    d2= +0.11155
+    d3= -0.01843
+    d4= -0.0044
+    d5= 0
+
+
+    pressure1 = p5*FDS_normalized_1**5 + p4*FDS_normalized_1**4 + p3*FDS_normalized_1**3 + p2*FDS_normalized_1**2 +p1*FDS_normalized_1**1 + p0
+    pressure2 = p5*FDS_normalized_2**5 + p4*FDS_normalized_2**4 + p3*FDS_normalized_2**3 + p2*FDS_normalized_2**2 +p1*FDS_normalized_2**1 + p0
+    pressure_final = (pressure1 + pressure2)/2
+    uncer_pressure_final = 8.7 + (np.maximum(pressure1, pressure2) - np.minimum(pressure1, pressure2))/(2*np.sqrt(3))  #uncertainty=8
+
+
+    density1 = d5*FDS_normalized_1**5 + d4*FDS_normalized_1**4 + d3*FDS_normalized_1**3 + d2*FDS_normalized_1**2 + d1*FDS_normalized_1**1 + d0
+    density2 = d5*FDS_normalized_2**5 + d4*FDS_normalized_2**4 + d3*FDS_normalized_2**3 + d2*FDS_normalized_2**2 + d1*FDS_normalized_2**1 + d0
+    
+    densityPW = d5*FDS_normalized**5 + d4*FDS_normalized**4 + d3*FDS_normalized**3 + d2*FDS_normalized**2 + d1*FDS_normalized**1 + d0
+        
+    density_final = (density1 + density2)/2
+    uncer_density_final = 0.006 + (np.maximum(density1,density2)-np.minimum(density1,density2))/(2*np.sqrt(3)) #uncertainty = 0.003
+    
+
+    if len(FDS)==1:
+        df=pd.DataFrame(data={'Density': density_final,
+                                'Density_PW': densityPW,
+                           'Density_err': uncer_density_final,
+                           'Input_Split':FDS,
+                           'Split_err':uncer_FDS,
+                           'Split_Std':FDS_std,
+                           }, index=[0])
+    else:
+        df=pd.DataFrame(data={'Density': density_final,
+         'Density_PW': densityPW,
+                           'Density_err': uncer_density_final,
+                           'Input_Split':FDS,
+                           'Split_err':uncer_FDS,
+                           'Split_Std':FDS_std,
+
+                           })
+        
+    return df
 
 

DiadFit/density_depth_crustal_profiles.py

@@ -76,6 +76,33 @@ def ryan_lerner(P_kbar):
 
     return D
 
+
+def denlinger_lerner(P_kbar):
+    """ Calculates depth for a given pressure using the Parameterization of Denlinger and Flinders (2022) with the addition of 200 kg/m3 at shallow depths, from Lerner et al. (2024).
+    After 15 km returns NaN following Lerner
+
+    Parameters
+    -------------
+    P_kbar: int, float, pd.series
+        Pressure in kbar
+
+    Returns
+    -------------
+    Depth in km (same datatype as input)
+
+
+    """
+
+    D=0.0684*P_kbar**3 - 0.5008*P_kbar**2 + 4.47*P_kbar
+    if D>15:
+        D=np.nan
+
+    return D
+
+
+
+
+
 def mavko_debari(P_kbar):
     """ Calculates depth for a given pressure using the parameterization of Mavko and Thompson (1983) and DeBari and Greene (2011)
     as given in Putirka (2017) Down the Crater Elements supplement, used for Cascades
@@ -143,7 +170,7 @@ def prezzi(P_kbar):
     return D
 
 
-Profile_funcs={ryan_lerner, mavko_debari, hill_zucca, prezzi, rasmussen}
+Profile_funcs={ryan_lerner, denlinger_lerner, mavko_debari, hill_zucca, prezzi, rasmussen}
 Profile_funcs_by_name= {p.__name__: p for p in Profile_funcs}
 
 
@@ -223,7 +250,7 @@ def loop_pressure_depth_2step(P_kbar=None, d1=14, rho1=2800, rho2=3100, g=9.81):
         depth_km_loop=convert_pressure_depth_2step(P_kbar,
             d1=d1, rho1=rho1, rho2=rho2, g=g)
     else:
-        depth_km_loop=np.empty(len(P_kbar))
+        depth_km_loop=np.zeros(len(P_kbar))
         for i in range(0, len(P_kbar)):
             depth_km_loop[i]=convert_pressure_depth_2step(P_kbar[i],
             d1=d1, rho1=rho1, rho2=rho2, g=g)
@@ -328,7 +355,7 @@ def loop_pressure_depth_3step(P_kbar=None,  d1=5, d2=14,
             d1=d1, rho1=rho1, rho2=rho2, g=g)
     else:
 
-        depth_km_loop=np.empty(len(P_kbar))
+        depth_km_loop=np.zeros(len(P_kbar))
         for i in range(0, len(P_kbar)):
             depth_km_loop[i]=convert_pressure_depth_3step(P_kbar[i],
             d1=d1, d2=d2,rho1=rho1, rho2=rho2, rho3=rho3, g=g)
@@ -364,6 +391,11 @@ d1=None, d2=None,rho1=None, rho2=None, rho3=None, model=None):
             Parameterization of Ryan 1987, actual equation from Lerner et al. 2021
             After 16.88 km (455 MPa), assume density is 2.746, as density turns around again. This profile is tweaked for Hawaii
 
+        denlinger_lerner:
+            Parameterization of Denlinger and Flinders (2022) with the addition of 200 kg/m3 at shallow depths, from Lerner et al. (2024).
+            After 15 km returns NaN following Lerner
+
+
         mavko_debari:
             Parameterization of Mavko and Thompson (1983) and DeBari and Greene (2011)
             as given in Putirka (2017) Down the Crater Elements supplement.
@@ -463,12 +495,12 @@ d1=None, d2=None,rho1=None, rho2=None, rho3=None, model=None):
                 D=func(P_kbar)
 
             if isinstance(P_kbar, pd.Series):
-                D=np.empty(len(P_kbar), float)
+                D=np.zeros(len(P_kbar), float)
                 for i in range(0, len(P_kbar)):
                     D[i]=func(P_kbar.iloc[i])
 
             if isinstance(P_kbar, np.ndarray):
-                D=np.empty(len(P_kbar), float)
+                D=np.zeros(len(P_kbar), float)
                 for i in range(0, len(P_kbar)):
                     D[i]=func(P_kbar[i])
 

DiadFit/diads.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 from matplotlib import patches
 import lmfit
 from lmfit.models import GaussianModel, VoigtModel, LinearModel, ConstantModel, PseudoVoigtModel, Pearson4Model
-from scipy.signal import find_peaks, gaussian
+from scipy.signal import find_peaks
 import os
 import re
 from os import listdir
@@ -31,6 +31,17 @@ allowed_models = ["VoigtModel", "PseudoVoigtModel", "Pearson4Model", "SkewedVoig
 encode="ISO-8859-1"
 ## Ratio of different peaks
 
+
+def calculate_SO2_CO2_ratio(SO2_area, diad1_area, diad2_area, SO2_cross_sec=5.3, diad1_cross_sec=0.89, diad2_cross_sec=1.4):
+    """ Calculates SO2:CO2 ratio using the parameters from Marie-Camille Caumons lab"""
+
+
+    A_CO2_star=( diad1_area + diad2_area)/(diad2_cross_sec+diad1_cross_sec)
+    A_SO2_star=(SO2_area)/(SO2_cross_sec)
+    Ratio=A_SO2_star/(A_SO2_star+A_CO2_star)
+
+    return Ratio
+
 def calculate_mole_fraction_2comp(peak_area_a, peak_area_b, cross_section_a, cross_section_b, instrument_eff_a, instrument_eff_b):
     """ This function calculates the molar ration of 2 components a and b based on peak areas,
     cross section and instrument efficiency
@@ -61,7 +72,9 @@ def calculate_mole_fraction_2comp(peak_area_a, peak_area_b, cross_section_a, cro
     Sum_phase_a=peak_area_a/(cross_section_a*instrument_eff_a)
     Sum_phase_b=peak_area_b/(cross_section_b*instrument_eff_b)
 
-    df=pd.DataFrame(data={'A:B molar ratio': Sum_phase_a/Sum_phase_b})
+    df=pd.DataFrame(data={'% A': 100*Sum_phase_a/(Sum_phase_b+Sum_phase_a),
+    '% B': 100-100*Sum_phase_a/(Sum_phase_b+Sum_phase_a)}
+    )
 
     return df
 def plot_diad(*,path=None, filename=None, filetype='Witec_ASCII', Spectra_x=None, Spectra_y=None):
@@ -613,8 +626,8 @@ def loop_approx_diad_fits(*, spectra_path, config, Diad_Files, filetype, plot_fi
     # Now do for all files
     fit_params = pd.DataFrame([])
     x_cord=Diad[:, 0]
-    data_y_all=np.empty([  len(x_cord), len(Diad_Files)], float)
-    data_x_all=np.empty([  len(x_cord), len(Diad_Files)], float)
+    data_y_all=np.zeros([  len(x_cord), len(Diad_Files)], float)
+    data_x_all=np.zeros([  len(x_cord), len(Diad_Files)], float)
     i=0
     for file in tqdm(Diad_Files):
 
@@ -842,8 +855,8 @@ def identify_diad_group(*, fit_params, data_y,  x_cord, filter_bool,y_fig_scale=
     if np.shape(data_y)[1]==0:
         Group1_df=pd.DataFrame().reindex_like(fit_params)
         Groupnot1_df=pd.DataFrame().reindex_like(fit_params)
-        Group1_np_y=np.empty(0, dtype='float')
-        Groupnot1_np_y=np.empty(0, dtype='float')
+        Group1_np_y=np.zeros(0, dtype='float')
+        Groupnot1_np_y=np.zeros(0, dtype='float')
         return Group1_df, Groupnot1_df, Group1_np_y, Groupnot1_np_y
 
     else:
@@ -1647,7 +1660,6 @@ def fit_gaussian_voigt_generic_diad(config1, *, diad1=False, diad2=False, path=N
 
 
 
-
     # Calculate the amplitude from the sigma and the prominence
     calc_diad_amplitude=((config1.diad_sigma)*(config1.diad_prom))/0.3939
     calc_HB_amplitude=((config1.diad_sigma)*(config1.HB_prom))/0.3939
@@ -3186,6 +3198,7 @@ def fit_diad_1_w_bck(*, config1: diad1_fit_config=diad1_fit_config(), config2: d
         else:
             axc_xmin=config1.lower_bck_diad1[0]
             axc_xmax=config1.upper_bck_diad1[1]
+
         axc_ymin=np.min(Baseline_diad1[:, 1])-config1.y_range_baseline
         axc_ymax=np.max(Baseline_diad1[:, 1])+config1.y_range_baseline
 
@@ -3419,6 +3432,44 @@ def calculate_HB_Diad_area_ratio(df):
 
 @dataclass
 class generic_peak_config:
+    """
+    Configuration class for fitting secondary peaks (e.g. SO2, Carbonate)
+
+    Attributes:
+        name (str): Default 'Generic'
+            Name of component you are fitting that gets stamped onto the peak parameters, e.g. if 'SO2', get Peak_Area_SO2'
+
+        lower_bck, upper_bck: Tuple[float, float]
+            Background positions in wavenumbers
+
+        model_name: Default 'PseudoVoigt'
+            Type of peak fit. Choose from 'GaussianModel', 'VoigtModel', 'PseudoVoigtModel', 'Spline'.
+
+        x_range_bck: float (default 10)
+            When showing bck collected plot, shows peak center +- this amount
+
+        N_poly_carb_bck: float (default 1)
+            Degree of polynomial to fit to background.
+
+        amplitude: float (default 100)
+            Approximate amplitude of peak fit (first guess for Gaussian , voigt and Psuedovoigt needed)
+
+        cent: float (default 1090)
+            Approximate peak position of species you are looking for. E.g. 1090 for CO2, 1150 for SO2
+
+        outlier_sigma: float (default 12)
+            Code calculates standard deviation of background, and excludes points more than outlier_sigma*this standard deviatoin from nearby background points
+
+        distance, prominence, width, threshold, height: float
+            Scipy find peak parameters to get initial fit of peak
+
+
+
+
+        fit_peaks (int): Default 2
+            Number of peaks to fit. 2 = Diad + HB, 1 = Diad.
+
+    """
 
     # Name that gets stamped onto fits
     name: str= 'generic'
@@ -3566,24 +3617,24 @@ path=None, filename=None, filetype=None,
     # To make a nice plot, give 50 wavenumber units on either side as a buffer
     Spectra_plot=Spectra[ (Spectra[:,0]>lower_0baseline-50) & (Spectra[:,0]<upper_1baseline+50) ]
 
-    # Find peaks using Scipy find peaks
+    # # Find peaks using Scipy find peaks
     y=Spectra_fit[:, 1]
     x=Spectra_fit[:, 0]
     spec_res=np.abs(x[0]-x[1])
-
-
-    peaks = find_peaks(y,height = config.height, threshold = config.threshold,
-    distance = config.distance, prominence=config.prominence, width=config.width)
-
-    height = peaks[1]['peak_heights'] #list of the heights of the peaks
-    peak_pos = x[peaks[0]] #list of the peaks positions
-    df_sort=pd.DataFrame(data={'pos': peak_pos,
-                        'height': height})
-
-    df_peak_sort=df_sort.sort_values('height', axis=0, ascending=False)
-
-    # Trim number of peaks based on user-defined N peaks
-    df_peak_sort_short=df_peak_sort[0:config.N_peaks]
+    #
+    #
+    # peaks = find_peaks(y,height = config.height, threshold = config.threshold,
+    # distance = config.distance, prominence=config.prominence, width=config.width)
+    #
+    # height = peaks[1]['peak_heights'] #list of the heights of the peaks
+    # peak_pos = x[peaks[0]] #list of the peaks positions
+    # df_sort=pd.DataFrame(data={'pos': peak_pos,
+    #                     'height': height})
+    #
+    # df_peak_sort=df_sort.sort_values('height', axis=0, ascending=False)
+    #
+    # # Trim number of peaks based on user-defined N peaks
+    # df_peak_sort_short=df_peak_sort[0:config.N_peaks]
 
 
     # Get actual baseline
@@ -3828,33 +3879,19 @@ path=None, filename=None, filetype=None,
 
         if config.model_name != 'Spline' and config.model_name != 'Poly':
             ax2.plot(xx_carb, y_carb, '-k', label='Peak fit')
-            cent=df['Peak_Cent_{}'.format(name)].iloc[0]
-            ax2.set_xlim([cent-config.x_range_bck, cent+config.x_range_bck])
+
+
         else:
             ax2.plot(x_new, Baseline_ysub_sil, '-k')
             ax2.fill_between(x_new, Baseline_ysub_sil, color='yellow', label='fit area', alpha=0.5)
 
 
-        ax2.set_title('Bkg-subtracted, ' + name + ' peak fit')
-
-
-
-
-
+        cent=df['Peak_Cent_{}'.format(name)].iloc[0]
+        ax2.set_xlim([cent-config.x_range_bck, cent+config.x_range_bck])
 
+        ax2.set_title('Bkg-subtracted, ' + name + ' peak fit')
 
 
-    # ax2.set_ylim([min(y_carb)-0.5*(max(y_carb)-min(y_carb)),
-    #             max(y_carb)+0.1*max(y_carb),
-    # ])
-
-
-
-        if find_peaks is True:
-
-            ax1.plot(df_peak_sort_short['pos'], df_peak_sort_short['height'], '*k', mfc='yellow', label='SciPy Peaks')
-            ax1.plot(Spectra_short[:, 0], Py_base, '-k')
-
         ax1.set_ylabel('Intensity')
         ax1.set_xlabel('Wavenumber (cm$^{-1}$)')
         ax2.set_ylabel('Bck-corrected Intensity')
@@ -4010,15 +4047,15 @@ def plot_secondary_peaks(*, Diad_Files, path, filetype,
 
     i=0
     Y=0
-    peak_pos_saved=np.empty(len(Diad_Files), dtype=float)
-    peak_prom_saved=np.empty(len(Diad_Files), dtype=float)
-    peak_height_saved=np.empty(len(Diad_Files), dtype=float)
-    peak_bck=np.empty(len(Diad_Files), dtype=float)
-    y_star=np.empty(len(Diad_Files), dtype=float)
-    yplot=np.empty(len(Diad_Files), dtype=float)
+    peak_pos_saved=np.zeros(len(Diad_Files), dtype=float)
+    peak_prom_saved=np.zeros(len(Diad_Files), dtype=float)
+    peak_height_saved=np.zeros(len(Diad_Files), dtype=float)
+    peak_bck=np.zeros(len(Diad_Files), dtype=float)
+    y_star=np.zeros(len(Diad_Files), dtype=float)
+    yplot=np.zeros(len(Diad_Files), dtype=float)
     Diad_df=get_data(path=path, filename=Diad_Files[0], filetype=filetype)
     x_data=Diad_df[:, 0]
-    y_data=np.empty([  len(x_data), len(Diad_Files)], float)
+    y_data=np.zeros([  len(x_data), len(Diad_Files)], float)
 
 
     for file in Diad_Files: