From 6bbd6776b896bea21f4f6bfa846a6aecee7c0e59 Mon Sep 17 00:00:00 2001 From: rasmusvt Date: Wed, 29 Jun 2022 15:26:43 +0200 Subject: [PATCH] Tweaks based on workflow testing --- nafuma/auxillary.py | 14 +- nafuma/xanes/calib.py | 334 +++++++++++++++++++++++++----------------- 2 files changed, 214 insertions(+), 134 deletions(-) diff --git a/nafuma/auxillary.py b/nafuma/auxillary.py index 2b87479..0ccde1f 100644 --- a/nafuma/auxillary.py +++ b/nafuma/auxillary.py @@ -12,11 +12,21 @@ def update_options(options, required_options, default_options): return options -def save_options(options, path): +def save_options(options, path, ignore=None): ''' Saves any options dictionary to a JSON-file in the specified path''' + options_copy = options.copy() + + if ignore: + if not isinstance(ignore, list): + ignore = [ignore] + + for i in ignore: + options_copy[i] = 'Removed' + + with open(path, 'w') as f: - json.dump(options,f) + json.dump(options_copy,f, skipkeys=True, indent=4) def load_options(path): diff --git a/nafuma/xanes/calib.py b/nafuma/xanes/calib.py index 9bb13f4..22d63eb 100644 --- a/nafuma/xanes/calib.py +++ b/nafuma/xanes/calib.py @@ -46,12 +46,12 @@ def pre_edge_fit(data: dict, options={}) -> pd.DataFrame: # FIXME Add log-file - required_options = ['pre_edge_limit', 'masks', 'log', 'logfile', 'show_plots', 'save_plots', 'save_folder', 'ylim', 'interactive'] + required_options = ['pre_edge_limits', 'pre_edge_masks', 'pre_edge_polyorder', 'pre_edge_store_data', 'log', 'logfile', 'show_plots', 'save_plots', 'save_folder', 'ylim', 'interactive'] default_options = { 'pre_edge_limits': [None, None], 'pre_edge_masks': [], 'pre_edge_polyorder': 1, - 'pre_edge_save_data': False, + 'pre_edge_store_data': False, 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_pre_edge_fit.log', 'show_plots': False, @@ -159,7 +159,7 @@ def pre_edge_fit(data: dict, options={}) -> pd.DataFrame: if options['log']: aux.write_log(message=f'Pre edge fitting done.', options=options) - if options['pre_edge_save_data']: + if options['pre_edge_store_data']: data['pre_edge_fit_data'] = pre_edge_fit_data return pre_edge_fit_data @@ -171,7 +171,8 @@ def pre_edge_fit_interactive(data: dict, options: dict) -> None: w = widgets.interactive( btp.ipywidgets_update, func=widgets.fixed(pre_edge_fit), data=widgets.fixed(data), options=widgets.fixed(options), - pre_edge_limits=widgets.FloatRangeSlider(value=[options['pre_edge_limits'][0], options['pre_edge_limits'][1]], min=data['xanes_data_original']['ZapEnergy'].min(), max=data['xanes_data_original']['ZapEnergy'].max(), step=0.001) + pre_edge_limits=widgets.FloatRangeSlider(value=[options['pre_edge_limits'][0], options['pre_edge_limits'][1]], min=data['xanes_data_original']['ZapEnergy'].min(), max=data['xanes_data_original']['ZapEnergy'].max(), step=0.001), + pre_edge_store_data=widgets.Checkbox(value=options['pre_edge_store_data']) ) options['widget'] = w @@ -183,12 +184,14 @@ def pre_edge_fit_interactive(data: dict, options: dict) -> None: def pre_edge_subtraction(data: dict, options={}): - required_options = ['log', 'logfile', 'save_plots', 'save_folder'] + required_options = ['log', 'logfile', 'show_plots', 'save_plots', 'save_folder', 'pre_edge_subtraction_store_data'] default_options = { 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_pre_edge_subtraction.log', + 'show_plots': False, 'save_plots': False, - 'save_folder': './' + 'save_folder': './', + 'pre_edge_subtraction_store_data': False } options = aux.update_options(options=options, required_options=required_options, default_options=default_options) @@ -203,19 +206,28 @@ def pre_edge_subtraction(data: dict, options={}): xanes_data_bkgd_subtracted.insert(1, filename, data['xanes_data_original'][filename] - data['pre_edge_fit_data'][filename]) - if options['save_plots']: - if not os.path.isdir(options['save_folder']): - os.makedirs(options['save_folder']) + if options['save_plots'] or options['show_plots']: - dst = os.path.join(options['save_folder'], os.path.basename(filename)) + '_pre_edge_subtraction.png' fig, ax = plt.subplots(figsize=(10,5)) - data['xanes_data_original'].plot(x='ZapEnergy', y=filename, color='black', ax=ax) - xanes_data_bkgd_subtracted.plot(x='ZapEnergy', y=filename, color='red', ax=ax) + data['xanes_data_original'].plot(x='ZapEnergy', y=filename, color='black', ax=ax, label='Original data') + xanes_data_bkgd_subtracted.plot(x='ZapEnergy', y=filename, color='red', ax=ax, label='Pre edge subtracted') ax.set_title(f'{os.path.basename(filename)} - After subtraction', size=20) - plt.savefig(dst) - plt.close() + + if options['save_plots']: + if not os.path.isdir(options['save_folder']): + os.makedirs(options['save_folder']) + + dst = os.path.join(options['save_folder'], os.path.basename(filename)) + '_pre_edge_subtraction.png' + + plt.savefig(dst) + + if not options['show_plots']: + plt.close() + + if options['pre_edge_subtraction_store_data']: + data['xanes_data'] = xanes_data_bkgd_subtracted return xanes_data_bkgd_subtracted @@ -230,14 +242,14 @@ def post_edge_fit(data: dict, options={}): ''' - required_options = ['log', 'logfile', 'post_edge_masks', 'post_edge_limits', 'post_edge_polyorder', 'interactive', 'show_plots', 'save_plots', 'save_folder'] + required_options = ['log', 'logfile', 'post_edge_masks', 'post_edge_limits', 'post_edge_polyorder', 'post_edge_store_data', 'interactive', 'show_plots', 'save_plots', 'save_folder'] default_options = { 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_post_edge_fit.log', 'post_edge_limits': [None, None], 'post_edge_masks': [], 'post_edge_polyorder': 2, - 'post_edge_save_data': False, + 'post_edge_store_data': False, 'interactive': False, 'show_plots': False, 'save_plots': False, @@ -283,10 +295,10 @@ def post_edge_fit(data: dict, options={}): for i, filename in enumerate(data['path']): if options['log']: - aux.write_log(message=f'Fitting post edge on {os.path.basename(filename)} ({i+1} / {len(data["path"])}) with polynomial order {options["polyorder"]}', options=options) + aux.write_log(message=f'Fitting post edge on {os.path.basename(filename)} ({i+1} / {len(data["path"])}) with polynomial order {options["post_edge_polyorder"]}', options=options) #Fitting linear function to the background - params = np.polyfit(post_edge_data["ZapEnergy"], post_edge_data[filename], options['polyorder']) + params = np.polyfit(post_edge_data["ZapEnergy"], post_edge_data[filename], options['post_edge_polyorder']) fit_function = np.poly1d(params) if options['log']: @@ -340,7 +352,7 @@ def post_edge_fit(data: dict, options={}): if options['log']: aux.write_log(message='Post edge fitting done!', options=options) - if options['post_edge_save_data']: + if options['post_edge_store_data']: data['post_edge_fit_data'] = post_edge_fit_data @@ -352,7 +364,8 @@ def post_edge_fit_interactive(data: dict, options: dict) -> None: w = widgets.interactive( btp.ipywidgets_update, func=widgets.fixed(post_edge_fit), data=widgets.fixed(data), options=widgets.fixed(options), - post_edge_limit=widgets.FloatRangeSlider(value=[options['post_edge.limits'][0], options['post_edge.limits'][1]], min=data['xanes_data_original']['ZapEnergy'].min(), max=data['xanes_data_original']['ZapEnergy'].max(), step=0.001) + post_edge_limits=widgets.FloatRangeSlider(value=[options['post_edge_limits'][0], options['post_edge_limits'][1]], min=data['xanes_data_original']['ZapEnergy'].min(), max=data['xanes_data_original']['ZapEnergy'].max(), step=0.001), + post_edge_store_data=widgets.Checkbox(value=options['post_edge_store_data']) ) options['widget'] = w @@ -364,16 +377,19 @@ def smoothing(data: dict, options={}): # FIXME Add logging # FIXME Add saving of files - required_options = ['log', 'logfile', 'show_plots', 'save_plots', 'save_folder', 'smooth_window_length', 'smooth_algorithm', 'smooth_polyorder', 'smooth_save_default'] + required_options = ['log', 'logfile', 'show_plots', 'save_plots', 'save_folder', 'interactive', 'smooth_window_length', 'smooth_algorithm', 'smooth_polyorder', 'smooth_save_default', 'smooth_store_data'] default_options = { 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_smoothing.log', + 'show_plots': False, 'save_plots': False, 'save_folder': './', + 'interactive': False, 'smooth_window_length': 3, 'smooth_polyorder': 2, 'smooth_algorithm': 'savgol', # At the present, only Savitzky-Golay filter is implemented. Add Gaussian and Boxcar later. 'smooth_save_default': False, + 'smooth_store_data': False, } options = aux.update_options(options=options, required_options=required_options, default_options=default_options) @@ -387,6 +403,7 @@ def smoothing(data: dict, options={}): if options['interactive']: + data['xanes_data_backup'] = data['xanes_data'] options['interactive'] = False options['interactive_session_active'] = True options['show_plots'] = True @@ -405,7 +422,7 @@ def smoothing(data: dict, options={}): df_smooth.insert(1, filename, savgol_filter(data['xanes_data'][filename], options['smooth_window_length'], options['smooth_polyorder'])) if options['smooth_save_default']: - if options['smooth.algorithm'] == 'savgol': + if options['smooth_algorithm'] == 'savgol': if options['log']: aux.write_log(message=f'Smoothing {filename} using default parameters with algorithm: {options["smooth_algorithm"]} ({i+1}/{len(data["path"])})', options=options) df_smooth_default.insert(1, filename, savgol_filter(data['xanes_data'][filename], default_options['smooth_window_length'], default_options['smooth_polyorder'])) @@ -413,27 +430,36 @@ def smoothing(data: dict, options={}): if options['save_plots'] or options['show_plots']: + + edge_pos = estimate_edge_position(data=data, options=options) intensity_midpoint = df_smooth[filename].iloc[np.where(df_smooth['ZapEnergy'] == find_nearest(df_smooth['ZapEnergy'], edge_pos))].values[0] + step_length = data['xanes_data']['ZapEnergy'].iloc[1] - data['xanes_data']['ZapEnergy'].iloc[0] + + if options['smooth_save_default']: fig, (ax1, ax2) = plt.subplots(1,2,figsize=(20,5)) - data['xanes_data'].loc[(data['xanes_data']['ZapEnergy'] > edge_pos-0.0015) & (data['xanes_data']['ZapEnergy'] < edge_pos+0.0015)].plot(x='ZapEnergy', y=filename, color='black', ax=ax1, kind='scatter') - df_smooth.loc[(df_smooth['ZapEnergy'] > edge_pos-0.0015) & (df_smooth['ZapEnergy'] < edge_pos+0.0015)].plot(x='ZapEnergy', y=filename, color='red', ax=ax1) + data['xanes_data'].loc[(data['xanes_data']['ZapEnergy'] > edge_pos-10*step_length) & (data['xanes_data']['ZapEnergy'] < edge_pos+10*step_length)].plot(x='ZapEnergy', y=filename, color='black', ax=ax1, kind='scatter') + df_smooth.loc[(df_smooth['ZapEnergy'] > edge_pos-10*step_length) & (df_smooth['ZapEnergy'] < edge_pos+10*step_length)].plot(x='ZapEnergy', y=filename, color='red', ax=ax1) ax1.set_title(f'{os.path.basename(filename)} - Smooth', size=20) - data['xanes_data'].loc[(data['xanes_data']['ZapEnergy'] > edge_pos-0.0015) & (data['xanes_data']['ZapEnergy'] < edge_pos+0.0015)].plot(x='ZapEnergy', y=filename, color='black', ax=ax2, kind='scatter') - df_smooth_default.loc[(df_smooth_default['ZapEnergy'] > edge_pos-0.0015) & (df_smooth_default['ZapEnergy'] < edge_pos+0.0015)].plot(x='ZapEnergy', y=filename, color='red', ax=ax2) + data['xanes_data'].loc[(data['xanes_data']['ZapEnergy'] > edge_pos-10*step_length) & (data['xanes_data']['ZapEnergy'] < edge_pos+10*step_length)].plot(x='ZapEnergy', y=filename, color='black', ax=ax2, kind='scatter') + df_smooth_default.loc[(df_smooth_default['ZapEnergy'] > edge_pos-10*step_length) & (df_smooth_default['ZapEnergy'] < edge_pos+10*step_length)].plot(x='ZapEnergy', y=filename, color='red', ax=ax2) ax2.set_title(f'{os.path.basename(filename)} - Smooth (default values)', size=20) - elif not options['save_default']: - fig, ax = plt.subplots(figsize=(20,10)) - data['xanes_data'].loc[(data['xanes_data']['ZapEnergy'] > edge_pos-0.0015) & (data['xanes_data']['ZapEnergy'] < edge_pos+0.0015)].plot(x='ZapEnergy', y=filename, color='black', ax=ax, kind='scatter') - df_smooth.loc[(df_smooth['ZapEnergy'] > edge_pos-0.0015) & (df_smooth['ZapEnergy'] < edge_pos+0.0015)].plot(x='ZapEnergy', y=filename, color='red', ax=ax) - ax.set_xlim([edge_pos-0.0015, edge_pos+0.0015]) - ax.set_ylim([intensity_midpoint*0.9, intensity_midpoint*1.1]) + elif not options['smooth_save_default']: + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20,10)) + data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, kind='scatter', c='black') + df_smooth.plot(x='ZapEnergy', y=filename, ax=ax1, c='red') + + data['xanes_data'].loc[(data['xanes_data']['ZapEnergy'] > edge_pos-10*step_length) & (data['xanes_data']['ZapEnergy'] < edge_pos+10*step_length)].plot(x='ZapEnergy', y=filename, color='black', ax=ax2, kind='scatter') + df_smooth.loc[(df_smooth['ZapEnergy'] > edge_pos-10*step_length) & (df_smooth['ZapEnergy'] < edge_pos+10*step_length)].plot(x='ZapEnergy', y=filename, color='red', ax=ax2) + #ax.set_xlim([edge_pos-0.0015, edge_pos+0.0015]) + #ax.set_ylim([intensity_midpoint*0.9, intensity_midpoint*1.1]) - ax.set_title(f'{os.path.basename(filename)} - Smooth', size=20) + ax1.set_title(f'{os.path.basename(filename)} - Smooth', size=20) + ax2.set_title(f'{os.path.basename(filename)} - Smooth Edge Region', size=20) if options['save_plots']: if not os.path.isdir(options['save_folder']): @@ -445,8 +471,12 @@ def smoothing(data: dict, options={}): if not options['show_plots']: plt.close() - if not options['save_default']: + if not options['smooth_save_default']: df_smooth_default = None + + if options['smooth_store_data']: + data['xanes_data'] = df_smooth + options['smooth_store_data'] = False return df_smooth, df_smooth_default @@ -457,16 +487,21 @@ def smoothing_interactive(data: dict, options: dict) -> None: w = widgets.interactive( btp.ipywidgets_update, func=widgets.fixed(smoothing), data=widgets.fixed(data), options=widgets.fixed(options), - smooth_window_length=widgets.IntSlider(value=options['smooth_window_length'], min=1, max=20, step=1), + smooth_window_length=widgets.IntSlider(value=options['smooth_window_length'], min=3, max=21, step=2), smooth_polyorder=widgets.IntSlider(value=options['smooth_polyorder'], min=1, max=5, step=1), + smooth_store_data=widgets.Checkbox(value=options['smooth_store_data']) ) - options['widget'] = w display(w) +def restore_from_backup(data): + if 'xanes_data_bakcup' in data.keys(): + data['xanes_data'] = data['xanes_data_backup'] + + def find_nearest(array, value): #function to find the value closes to "value" in an "array" array = np.asarray(array) @@ -480,7 +515,7 @@ def estimate_edge_position(data: dict, options={}, index=0): default_options = { 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_edge_position_estimation.log', - 'periods': 2, #Periods needs to be an even number for the shifting of values to work properly + 'periods': 6, #Periods needs to be an even number for the shifting of values to work properly } options = aux.update_options(options=options, required_options=required_options, default_options=default_options) @@ -509,7 +544,7 @@ def determine_edge_position(data: dict, options={}): Requires that XANES-data is already loaded in data['xanes_data']. This allows the user to choose when to determine the edge position - whether before or after normalisation, flattening etc.''' - required_options = ['save_values', 'log', 'logfile', 'save_plots', 'save_folder', 'diff', 'diff.polyorder', 'diff.periods', 'double_diff', 'double_diff.polyorder', 'double_diff.periods', 'fit_region'] + required_options = ['save_values', 'log', 'logfile', 'show_plots', 'save_plots', 'save_folder', 'diff', 'diff.polyorder', 'diff.periods', 'double_diff', 'double_diff.polyorder', 'double_diff.periods', 'points_around_edge'] default_options = { 'save_values': True, # Whether the edge positions should be stored in a dictionary within the main data dictionary. 'log': False, # Toggles logging on/off @@ -521,9 +556,9 @@ def determine_edge_position(data: dict, options={}): 'diff.polyorder': 2, # Sets the order of the polynomial to fit edge region of the differential to 'diff.periods': 2, # Sets the number of data points between which the first order difference should be calculated. Needs to be even for subsequent shifting of data to function. 'double_diff': False, # Toggles calculation of the edge position based on double differential data - 'double_diff.polyorder': 2, # Sets the order of the polynomial to fit edge region of the double differential to + 'double_diff.polyorder': 1, # Sets the order of the polynomial to fit edge region of the double differential to 'double_diff.periods': 2, # Sets the number of data points between which the second order difference should be calculated. Needs to be even for subsequent shifting of data to function. - 'fit_region': None # The length of the region to find points to fit to a function + 'points_around_edge': 5 # The length of the region to find points to fit to a function } options = aux.update_options(options=options, required_options=required_options, default_options=default_options) @@ -538,6 +573,16 @@ def determine_edge_position(data: dict, options={}): aux.write_log(message='Periods for double differentiation is not even. Ending run.', options=options) raise Exception("NB! Periods needs to be an even number for the shifting of values to work properly") + + if options['interactive']: + data['xanes_data_backup'] = data['xanes_data'] + options['interactive'] = False + options['interactive_session_active'] = True + options['show_plots'] = True + determine_edge_position_interactive(data=data, options=options) + return + + # Prepare dataframes for differential data @@ -554,8 +599,8 @@ def determine_edge_position(data: dict, options={}): for i, filename in enumerate(data['path']): estimated_edge_pos = estimate_edge_position(data, options=options, index=i) - if not options['fit_region']: - options['fit_region'] = (5)*(data['xanes_data']['ZapEnergy'].iloc[1] - data['xanes_data']['ZapEnergy'].iloc[0]) + + fit_region = (options['points_around_edge']+1)*(data['xanes_data']['ZapEnergy'].iloc[1] - data['xanes_data']['ZapEnergy'].iloc[0]) #========================== Fitting the first order derivative ========== @@ -565,7 +610,7 @@ def determine_edge_position(data: dict, options={}): df_diff[filename]=df_diff[filename].shift(-int(options['diff.periods']/2)) # Shifts the data back so that the difference between the points is located in the middle of the two points the caluclated difference is between # Picks out the points to be fitted - df_diff_edge = df_diff.loc[(df_diff["ZapEnergy"] <= estimated_edge_pos+options['fit_region']) & ((df_diff["ZapEnergy"] >= estimated_edge_pos-options['fit_region']))] + df_diff_edge = df_diff.loc[(df_diff["ZapEnergy"] <= estimated_edge_pos+fit_region) & ((df_diff["ZapEnergy"] >= estimated_edge_pos-fit_region))] # Fitting a function to the chosen interval @@ -594,7 +639,7 @@ def determine_edge_position(data: dict, options={}): df_double_diff[filename]=df_double_diff[filename].shift(-int(options['double_diff.periods'])) # Pick out region of interest - df_double_diff_edge = df_double_diff.loc[(df_double_diff["ZapEnergy"] < estimated_edge_pos+options['fit_region']) & ((df_double_diff["ZapEnergy"] > estimated_edge_pos-options['fit_region']))] + df_double_diff_edge = df_double_diff.loc[(df_double_diff["ZapEnergy"] < estimated_edge_pos+fit_region) & ((df_double_diff["ZapEnergy"] > estimated_edge_pos-fit_region))] # Fitting a function to the chosen interval params = np.polyfit(df_double_diff_edge["ZapEnergy"], df_double_diff_edge[filename], options['double_diff.polyorder']) @@ -621,100 +666,100 @@ def determine_edge_position(data: dict, options={}): data['e0_double_diff'][filename] = edge_pos_double_diff - # Make and show / save plots - if options['save_plots'] or options['show_plots']: + # Make and show / save plots + if options['save_plots'] or options['show_plots']: - # If both are enabled - if options['diff'] and options['double_diff']: - - fig, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(ncols=3, nrows=2, figsize=(20,20)) - data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, c='black') - ax1.axvline(x=edge_pos_diff, ls='--', c='green') - - df_diff.plot(x='ZapEnergy', y=filename, ax=ax2, kind='scatter') - df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax2) - ax2.set_xlim([edge_pos_diff-0.0015, edge_pos_diff+0.0015]) - ax2.axvline(x=estimated_edge_pos-options['fit_region'], ls='--', c='black') - ax2.axvline(x=edge_pos_diff, ls='--', c='green') - ax2.axvline(x=estimated_edge_pos+options['fit_region'], ls='--', c='black') - ax2.set_title('Fit region of differentiated data') + # If both are enabled + if options['diff'] and options['double_diff']: - df_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax3, kind='scatter') - df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax3) - ax3.axvline(x=edge_pos_diff, ls='--', c='green') - ax3.axvline(x=estimated_edge_pos, ls='--', c='red') - ax3.set_title('Fit of differentiated data') + fig, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(ncols=3, nrows=2, figsize=(20,20)) + data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, c='black') + ax1.axvline(x=edge_pos_diff, ls='--', c='green') + + df_diff.plot(x='ZapEnergy', y=filename, ax=ax2, kind='scatter') + df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax2) + ax2.set_xlim([edge_pos_diff-fit_region*1.5, edge_pos_diff+fit_region*1.5]) + ax2.axvline(x=estimated_edge_pos-fit_region, ls='--', c='black') + ax2.axvline(x=edge_pos_diff, ls='--', c='green') + ax2.axvline(x=estimated_edge_pos+fit_region, ls='--', c='black') + ax2.set_title('Fit region of differentiated data') + + df_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax3, kind='scatter') + df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax3) + ax3.axvline(x=edge_pos_diff, ls='--', c='green') + ax3.axvline(x=estimated_edge_pos, ls='--', c='red') + ax3.set_title('Fit of differentiated data') - data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax4, c='black') - ax4.axvline(x=edge_pos_double_diff, ls='--', c='green') + data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax4, c='black') + ax4.axvline(x=edge_pos_double_diff, ls='--', c='green') - df_double_diff.plot(x='ZapEnergy', y=filename, ax=ax5, kind='scatter') - df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax5) - ax5.set_xlim([edge_pos_double_diff-0.0015, edge_pos_double_diff+0.0015]) - ax5.axvline(x=estimated_edge_pos-options['fit_region'], ls='--', c='black') - ax5.axvline(x=edge_pos_double_diff, ls='--', c='green') - ax5.axvline(x=estimated_edge_pos+options['fit_region'], ls='--', c='black') + df_double_diff.plot(x='ZapEnergy', y=filename, ax=ax5, kind='scatter') + df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax5) + ax5.set_xlim([edge_pos_double_diff-0.0015, edge_pos_double_diff+0.0015]) + ax5.axvline(x=estimated_edge_pos-fit_region, ls='--', c='black') + ax5.axvline(x=edge_pos_double_diff, ls='--', c='green') + ax5.axvline(x=estimated_edge_pos+fit_region, ls='--', c='black') - df_double_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax6, kind='scatter') - df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax6) - ax6.axvline(x=edge_pos_double_diff, ls='--', c='green') - ax6.axvline(x=estimated_edge_pos, ls='--', c='red') - + df_double_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax6, kind='scatter') + df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax6) + ax6.axvline(x=edge_pos_double_diff, ls='--', c='green') + ax6.axvline(x=estimated_edge_pos, ls='--', c='red') + - # If only first order differentials is enabled - elif options['diff']: - fig, (ax1, ax2, ax3) = plt.subplots(ncols=3,nrows=1, figsize=(20, 10)) - - data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, c='black') - ax1.axvline(x=edge_pos_diff, ls='--', c='green') + # If only first order differentials is enabled + elif options['diff']: + fig, (ax1, ax2, ax3) = plt.subplots(ncols=3,nrows=1, figsize=(20, 10)) + + data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, c='black') + ax1.axvline(x=edge_pos_diff, ls='--', c='green') - df_diff.plot(x='ZapEnergy', y=filename, ax=ax2, kind='scatter') - df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax2) - ax2.set_xlim([edge_pos_diff-0.5, edge_pos_diff+0.5]) - ax2.axvline(x=edge_pos_diff-options['fit_region'], ls='--', c='black') - ax2.axvline(x=edge_pos_diff, ls='--', c='green') - ax2.axvline(x=edge_pos_diff+options['fit_region'], ls='--', c='black') + df_diff.plot(x='ZapEnergy', y=filename, ax=ax2, kind='scatter') + df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax2) + ax2.set_xlim([edge_pos_diff-fit_region*1.5, edge_pos_diff+fit_region*1.5]) + ax2.axvline(x=edge_pos_diff-fit_region, ls='--', c='black') + ax2.axvline(x=edge_pos_diff, ls='--', c='green') + ax2.axvline(x=edge_pos_diff+fit_region, ls='--', c='black') - df_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax3) - df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax3) - ax3.axvline(x=edge_pos_diff, ls='--', c='green') - ax3.axvline(x=estimated_edge_pos, ls='--', c='red') + df_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax3) + df_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax3) + ax3.axvline(x=edge_pos_diff, ls='--', c='green') + ax3.axvline(x=estimated_edge_pos, ls='--', c='red') - # If only second order differentials is enabled - elif options['double_diff']: - fig, (ax1, ax2, ax3) = plt.subplots(ncols=3,nrows=1, figsize=(20, 10)) - - data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, c='black') - ax1.axvline(x=edge_pos_double_diff, ls='--', c='green') + # If only second order differentials is enabled + elif options['double_diff']: + fig, (ax1, ax2, ax3) = plt.subplots(ncols=3,nrows=1, figsize=(20, 10)) + + data['xanes_data'].plot(x='ZapEnergy', y=filename, ax=ax1, c='black') + ax1.axvline(x=edge_pos_double_diff, ls='--', c='green') - df_double_diff.plot(x='ZapEnergy', y=filename, ax=ax2, kind='scatter') - df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax2) - ax2.set_xlim([edge_pos_double_diff-0.5, edge_pos_double_diff+0.5]) - ax2.axvline(x=edge_pos_double_diff-options['fit_region'], ls='--', c='black') - ax2.axvline(x=edge_pos_double_diff, ls='--', c='green') - ax2.axvline(x=edge_pos_double_diff+options['fit_region'], ls='--', c='black') + df_double_diff.plot(x='ZapEnergy', y=filename, ax=ax2, kind='scatter') + df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax2) + ax2.set_xlim([edge_pos_double_diff-fit_region*1.5, edge_pos_double_diff+fit_region*1.5]) + ax2.axvline(x=edge_pos_double_diff-fit_region, ls='--', c='black') + ax2.axvline(x=edge_pos_double_diff, ls='--', c='green') + ax2.axvline(x=edge_pos_double_diff+fit_region, ls='--', c='black') - df_double_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax3) - df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax3) - ax3.axvline(x=edge_pos_double_diff, ls='--', c='green') - ax3.axvline(x=estimated_edge_pos, ls='--', c='red') + df_double_diff_edge.plot(x='ZapEnergy', y=filename, ax=ax3) + df_double_diff_fit_function.plot(x='x_diff', y='y_diff', ax=ax3) + ax3.axvline(x=edge_pos_double_diff, ls='--', c='green') + ax3.axvline(x=estimated_edge_pos, ls='--', c='red') - # Save plots if toggled - if options['save_plots']: - if not os.path.isdir(options['save_folder']): - os.makedirs(options['save_folder']) + # Save plots if toggled + if options['save_plots']: + if not os.path.isdir(options['save_folder']): + os.makedirs(options['save_folder']) - dst = os.path.join(options['save_folder'], os.path.basename(filename)) + '_edge_position.png' + dst = os.path.join(options['save_folder'], os.path.basename(filename)) + '_edge_position.png' - plt.savefig(dst, transparent=False) + plt.savefig(dst, transparent=False) - # Close plots if show_plots not toggled - if not options['show_plots']: - plt.close() + # Close plots if show_plots not toggled + if not options['show_plots']: + plt.close() if not options['diff']: @@ -724,35 +769,59 @@ def determine_edge_position(data: dict, options={}): return edge_pos_diff, edge_pos_double_diff + + +def determine_edge_position_interactive(data: dict, options: dict) -> None: + ''' Defines the widgets to use with the ipywidgets interactive mode and calls the update function found in btp.ipywidgets. ''' + + + step_size = data['xanes_data']['ZapEnergy'].iloc[1] - data['xanes_data']['ZapEnergy'].iloc[0] + + w = widgets.interactive( + btp.ipywidgets_update, func=widgets.fixed(determine_edge_position), data=widgets.fixed(data), options=widgets.fixed(options), + points_around_edge=widgets.IntSlider(value=options['points_around_edge'], min=1, max=20, step=1), + ) + + options['widget'] = w + + display(w) + def normalise(data: dict, options={}): - required_options = ['log', 'logfile', 'save_values'] + required_options = ['log', 'logfile', 'normalisation_store_data'] default_options = { 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_normalisation.log', - 'save_values': True + 'normalisation_store_data': False, } options = aux.update_options(options=options, required_options=required_options, default_options=default_options) normalised_df = pd.DataFrame(data['xanes_data']['ZapEnergy']) data['normalisation_constants'] = {} + if options['normalisation_store_data']: + pre_edge_fit_data_norm = pd.DataFrame(data['pre_edge_fit_data']['ZapEnergy']) + post_edge_fit_data_norm = pd.DataFrame(data['post_edge_fit_data']['ZapEnergy']) #Finding the normalisation constant ยต_0(E_0), by subtracting the value of the pre-edge-line from the value of the post-edge line at e0 for filename in data['path']: - e0_ind = data['post_edge_fit_data'].loc[data['post_edge_fit_data']['ZapEnergy'] == find_nearest(data['post_edge_fit_data']['ZapEnergy'], data['e0'][filename])].index.values[0] + e0_ind = data['post_edge_fit_data'].loc[data['post_edge_fit_data']['ZapEnergy'] == find_nearest(data['post_edge_fit_data']['ZapEnergy'], data['e0_diff'][filename])].index.values[0] #norm = data['post_edge_fit_data'][filename].iloc[find_nearest(data['post_edge_fit_data'][filename], data['e0'][filename])] normalisation_constant = data['post_edge_fit_data'][filename].iloc[e0_ind] - data['pre_edge_fit_data'][filename].iloc[e0_ind] normalised_df.insert(1, filename, data['xanes_data'][filename] / normalisation_constant) + if options['normalisation_store_data']: + pre_edge_fit_data_norm.insert(1, filename, data['pre_edge_fit_data'][filename] / normalisation_constant) + post_edge_fit_data_norm.insert(1, filename, data['post_edge_fit_data'][filename] / normalisation_constant) + + + if options['normalisation_store_data']: + data['xanes_data'] = normalised_df # Normalise the pre-edge and post-edge fit function data - data['pre_edge_fit_data'][filename] = data['pre_edge_fit_data'][filename] / normalisation_constant - data['post_edge_fit_data'][filename] = data['post_edge_fit_data'][filename] / normalisation_constant + data['pre_edge_fit_data_norm'] = pre_edge_fit_data_norm + data['post_edge_fit_data_norm'] = post_edge_fit_data_norm data['normalisation_constants'][filename] = normalisation_constant - if options['save_values']: - data['xanes_data'] = normalised_df - return normalised_df @@ -760,11 +829,11 @@ def normalise(data: dict, options={}): def flatten(data:dict, options={}): #only picking out zapenergy-values higher than edge position (edge pos and below remains untouched) - required_options = ['log', 'logfile', 'save_values'] + required_options = ['log', 'logfile', 'flatten_store_data'] default_options = { 'log': False, 'logfile': f'{datetime.now().strftime("%Y-%m-%d-%H-%M-%S")}_flattening.log', - 'save_values': True + 'flatten_store_data': False, } options = aux.update_options(options=options, required_options=required_options, default_options=default_options) @@ -772,13 +841,14 @@ def flatten(data:dict, options={}): flattened_df = pd.DataFrame(data['xanes_data']['ZapEnergy']) for filename in data['path']: - fit_function_diff = -data['post_edge_fit_data'][filename] + data['pre_edge_params'][filename][0] - fit_function_diff.loc[flattened_df['ZapEnergy'] <= data['e0'][filename]] = 0 + fit_function_diff = data['post_edge_fit_data_norm'][filename] - 1 + + fit_function_diff.loc[flattened_df['ZapEnergy'] <= data['e0_diff'][filename]] = 0 flattened_df[filename] = data['xanes_data'][filename] - fit_function_diff - if options['save_values']: + if options['flatten_store_data']: data['xanes_data'] = flattened_df