Temperature Calibration

Temperature Calibration¶

The following example is used to verify the TEAK method in preprocessing a TAP experiment. This experiment consists of several files in which only argon is pulsed into an inert reactor. The experiment is replicated for multiple temperatures and it is the goal to show that the moments are reflected correctly after proper baseline correction and calibration.

In [1]:

# imports
import tapsap
import copy
import plotly
import plotly.express as px
import pandas as pd
import numpy as np
plotly.offline.init_notebook_mode()
# read in the data, 100C
temperature_data = tapsap.read_tdms('../../TAPdata/RB_inert_with_temperature/05141438.tdms')
# creating two different data sets for comparing processes
argon_traditional = copy.deepcopy(temperature_data.species_data['AMU_40_1'])
argon_TEAK = copy.deepcopy(temperature_data.species_data['AMU_40_1'])
argon_traditional.set_moments()
argon_TEAK.set_moments()

The plot below shows the raw flux where the tail of the flux is below zero. This needs to be baseline corrected such that the moments will not be under estimated.

In [2]:

# plotting the 10th pulse
tapsap.plot_tap(argon_traditional.times, argon_traditional.flux.iloc[:,10])

In [3]:

# plotting the raw moments
tapsap.plot_tap(argon_traditional.df_moments['pulse_number'], argon_traditional.df_moments['M0'], x_lab='Pulse Number', y_lab='M0')

Based on the raw data, the baseline is definitely not zero and the M0 is drifting with respect to pulse number. To start the process, we will baseline correct the data per method Traditional vs TEAK where TEAK uses the baseline_gamma and calibrates the flux via calibration per pulse.

In [4]:

argon_traditional.baseline_correct(baseline_time_range=[4.5,5])
argon_TEAK.baseline_correct(smooth_flux = True)
argon_traditional.set_moments()
argon_TEAK.set_moments()

In [5]:

# comparing the M0 after baseline correction
df = pd.DataFrame({'Traditional':argon_traditional.df_moments['M0'], 'TEAK':argon_TEAK.df_moments['M0']})
tapsap.plot_tap(argon_traditional.df_moments['pulse_number'], df, legend = True, x_lab= 'Pulse Number', y_lab= 'M0')

In [6]:

# comparing the flux after baseline correction
df = pd.DataFrame({'Traditional':argon_traditional.flux.iloc[:,82], 'TEAK':argon_TEAK.flux.iloc[:,82]})
tapsap.plot_tap(argon_traditional.times, df, legend = True)

The flux are approximately the same whether using the baseline correction with a set time point or using baseline correction with the Gamma distribution. Note that pulse number 7 is an outlier and plotted below.

In [7]:

df = pd.DataFrame({'Traditional':argon_traditional.flux.iloc[:,6], 'TEAK':argon_TEAK.flux.iloc[:,6]})
tapsap.plot_tap(argon_traditional.times, df, legend = True)

Note that there still exists some drift with respect to pulse number. This data shows a small downward trend with respect to pulse number. This can be corrected using calibrate_flux with respect to a reference flux.

In [8]:

# calibrating the flux to flux number 3
argon_TEAK.calibrate_flux(reference_index = 2, smooth_flux = True, huber_loss = True, constraints = False)

In [9]:

# comparing the flux after calibration
df = pd.DataFrame({'Traditional at 3':argon_traditional.flux.iloc[:,2],'TEAK at 3':argon_TEAK.flux.iloc[:,2], 'Traditional at 99':argon_traditional.flux.iloc[:,98],'TEAK at 99':argon_TEAK.flux.iloc[:,98]})
tapsap.plot_tap(argon_traditional.times, df, legend = True)

The flux above does not show much difference visually from the traditional data. However, the moments after correcting by a reference flux stabalize the drift with respect to pulse number.

In [10]:

# comparing the M0 after pulse to pulse calibration
argon_TEAK.set_moments()
df = pd.DataFrame({'Traditional':argon_traditional.df_moments['M0'], 'TEAK':argon_TEAK.df_moments['M0']})
tapsap.plot_tap(argon_traditional.df_moments['pulse_number'], df, legend = True, x_lab= 'Pulse Number', y_lab= 'M0')

Removing the first and 7th pulse from the traditional method and plotting the histogram to visualize the spread of the moments (0.50 to 0.54).

In [11]:

# removing the first and 7th pulse from the traditional moments
traditional_moments = copy.deepcopy(argon_traditional.df_moments)
traditional_moments = traditional_moments.drop([0,6])

fig = px.histogram(traditional_moments, x="M0", nbins=10)
fig.show()

Removing the 7th pulse from the TEAK method and plotting the histogram to visualize the spread of the moments (0.52 to 0.54).

In [12]:

# removing the 7th pulse from the TEAK method
teak_moments = copy.deepcopy(argon_TEAK.df_moments)
teak_moments = teak_moments.drop([6])

fig = px.histogram(teak_moments, x="M0", nbins=10)
fig.show()

Application to multiple temperatures¶

The complete process is repeated as above but for each different temperature collected: 100C, 200C, 300C, 400C, and 500C.

In [13]:

# read the data
temperature_data_100C = tapsap.read_tdms('../../TAPdata/RB_inert_with_temperature/05141438.tdms')
temperature_data_200C = tapsap.read_tdms('../../TAPdata/RB_inert_with_temperature/05141513.tdms')
temperature_data_300C = tapsap.read_tdms('../../TAPdata/RB_inert_with_temperature/05141542.tdms')
temperature_data_400C = tapsap.read_tdms('../../TAPdata/RB_inert_with_temperature/05141610.tdms')
# creating two different data sets for comparing processes
traditional_100C = copy.deepcopy(temperature_data_100C.species_data['AMU_40_1'])
traditional_200C = copy.deepcopy(temperature_data_200C.species_data['AMU_40_1'])
traditional_300C = copy.deepcopy(temperature_data_300C.species_data['AMU_40_1'])
traditional_400C = copy.deepcopy(temperature_data_400C.species_data['AMU_40_1'])
teak_100C = copy.deepcopy(temperature_data_100C.species_data['AMU_40_1'])
teak_200C = copy.deepcopy(temperature_data_200C.species_data['AMU_40_1'])
teak_300C = copy.deepcopy(temperature_data_300C.species_data['AMU_40_1'])
teak_400C = copy.deepcopy(temperature_data_400C.species_data['AMU_40_1'])

In [14]:

#baseline correction
traditional_100C.baseline_correct(baseline_time_range=[4.5,5])
traditional_200C.baseline_correct(baseline_time_range=[4.5,5])
traditional_300C.baseline_correct(baseline_time_range=[4.5,5])
traditional_400C.baseline_correct(baseline_time_range=[4.5,5])
teak_100C.baseline_correct(smooth_flux = True)
teak_200C.baseline_correct(smooth_flux = True)
teak_300C.baseline_correct(smooth_flux = True)
teak_400C.baseline_correct(smooth_flux = True)

In [15]:

# teak pulse to pulse calibration
teak_100C.calibrate_flux(reference_index = 2, smooth_flux = True, huber_loss = True, constraints = False)
teak_200C.calibrate_flux(reference_index = 2, smooth_flux = True, huber_loss = True, constraints = False)
teak_300C.calibrate_flux(reference_index = 2, smooth_flux = True, huber_loss = True, constraints = False)
teak_400C.calibrate_flux(reference_index = 2, smooth_flux = True, huber_loss = True, constraints = False)

In [16]:

# set the moments
traditional_100C.set_moments()
traditional_200C.set_moments()
traditional_300C.set_moments()
traditional_400C.set_moments()
teak_100C.set_moments(smooth_flux=True, find_integration_times=True)
teak_200C.set_moments(smooth_flux=True, find_integration_times=True)
teak_300C.set_moments(smooth_flux=True, find_integration_times=True)
teak_400C.set_moments(smooth_flux=True, find_integration_times=True)

Plotting the resulting M0 against all temperatures and methods

In [17]:

traditional_df = pd.DataFrame({'100C':traditional_100C.df_moments['M0'],'200C':traditional_200C.df_moments['M0'], '300C':traditional_300C.df_moments['M0'],'400C':traditional_400C.df_moments['M0']})
tapsap.plot_tap(traditional_100C.df_moments['pulse_number'], traditional_df, legend = True, x_lab = 'Pulse Number',y_lab = 'M0')

In [18]:

teak_df = pd.DataFrame({'100C':teak_100C.df_moments['M0'],'200C':teak_200C.df_moments['M0'], '300C':teak_300C.df_moments['M0'],'400C':teak_400C.df_moments['M0']})
tapsap.plot_tap(teak_100C.df_moments['pulse_number'], teak_df, legend = True, x_lab = 'Pulse Number',y_lab = 'M0')

In [19]:

df = pd.DataFrame()
df['300C at 9'] = teak_300C.flux.iloc[:,8]
df['200C at 11'] = teak_200C.flux.iloc[:,10]
df['200C at 46'] = teak_200C.flux.iloc[:,45]
df['200C at 80'] = teak_200C.flux.iloc[:,79]
df['300C at 92'] = teak_300C.flux.iloc[:,91]
tapsap.plot_tap(argon_traditional.times, df, legend = True)

To compare the two results, the median absolute deviation is taken for the combined temperatures.

In [20]:

known_outgassing = [8, 10, 45, 62, 79, 83, 91]
traditional_df = traditional_df.drop(known_outgassing)
teak_df = teak_df.drop(known_outgassing)
traditional_combined = traditional_df.to_numpy().flatten()
teak_combined = teak_df.to_numpy().flatten()
print(np.mean(traditional_combined))
print(np.mean(teak_combined))
print(np.var(traditional_combined))
print(np.var(teak_combined))
print(np.var(traditional_combined) / np.var(teak_combined))

0.5180168254837462
0.5254788670340542
0.00016880028331764423
5.235267728714415e-06
32.242913269135755

The TEAK method was able to reduce the overall amount of variation by a factor of approximately 32, remove any drift within the pulse series, and does not require user input to remove any baseline effects.