DiadFit 0.0.85__py3-none-any.whl → 0.0.90__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,8 @@ 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':
+        print('yes')
         # 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 +526,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)
+            
+            
+    
+            
+    elif 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 +565,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 +579,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 +589,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 +611,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 +627,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 +668,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 +687,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 +786,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 +970,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 +1106,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 +1205,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 +1357,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,9 @@ 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
+from scipy.signal.windows import gaussian
+
 import os
 import re
 from os import listdir
@@ -31,6 +33,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 +74,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 +628,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 +857,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:
@@ -4034,15 +4049,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: