Calibration

Calibration¶

Calibration of the data is required as the scale of the outlet voltage response depends on the mass. For example, if using argon as an inert gas and oxygen as the reactant gas, then the mass spectrometer may measure each species on a different scale even if the injected molecular quantities are the same. Chemical measurements, such as conversion, moments and transient kinetics, are hence unreliable unless the outlet flux is properly calibrated.

Area based calibration¶

One way to deal with difference in scaling between multiple different masses is to perform an inert experiment (no catalyst) where the number of moleclues injected is the same for each species. The areas of each outlet flux per species is calculated to determine how the mass spectrometer is scaling each gas. This is done by taking the mean of all areas of a species and then comparing them to another species mean area. Any reaction species should be calibrated to the inert species since the inert only describes the transport in the reactor. For example, if an experiment consisted of measuring oxygen and argon let $\mu_O$ be the mean area of oxygen and $\mu_A$ be the mean area of argon, then the calibration coefficient for oxygen would be the ratio of the $\mu_A$ and $\mu_O$. Below is an example given previously calculated areas.

In [1]:

import numpy as np
# setting the arrays
mu_oxygen = np.array([0.4, 0.3, 0.6])
mu_argon = np.array([0.2, 0.15, 0.3])
calibration_coef = mu_argon.mean() / mu_oxygen.mean()
# calibration coefficient as 1/2
print(calibration_coef)

0.5

Once the calibration coefficient is determined from the inert experiment, the coefficient is then applied to the reaction experiment outlet flux per species. In tapsap, the calibration coefficient is applied to a flux by using the calibration_coef function. The argument of the function is the calibration amount and the return values are the flux and calibration amount.

In [2]:

# imports and reading the data
import tapsap
import pandas as pd
import plotly
plotly.offline.init_notebook_mode()
data = pd.read_csv('../tapsap/data/argon_100C_subset.csv')

In [3]:

flux = data['pulse_10'].values
times = data['times'].values
results = tapsap.calibration_coef(flux, 0.5)
calibrated_flux = results['flux']
df = pd.DataFrame({'flux':flux, 'calibrated flux':calibrated_flux})
tapsap.plot_tap(times, df, legend = True)

Flux based calibration¶

A potential drawback of using area based calibration is that there may exist drift in the instrument since performing the inert experiment or even during an experiment. This may be seen as a change in the mean area from day to day or even worse a non-linear change in the area per pulse during an experiment. One way to deal with this drift is to calibrate the information from pulse to pulse using the transient information (flux). In this way, a linear regression (with convex constraints for ensuring the number of molecules and area relations are maintained) can be made between pulses (calibrating a set of inert flux to a single pulse) or even between gas species (calibrating a reactant/product flux to the inert flux). This methodology is implemented in calibration_teak to determine the calibration coefficient (even in the presence of reaction) without requiring an inert experiment.

A simple example can be performed using the calibrated_flux values obtained earlier:

In [4]:

back_transformed_flux = tapsap.calibration_teak(calibrated_flux, flux, times, 40, 40)
df = pd.DataFrame({'flux':flux, 'fit flux':back_transformed_flux['flux']})
tapsap.plot_tap(times, df, legend = True)

Of course this is a simple example where the back transformed flux should the same as the original flux, but another example can be done with reaction data:

In [5]:

# reading in the data
reaction_data = pd.read_csv('../tapsap/data/irreversible.csv')
times = reaction_data['times'].values
inert_flux = reaction_data['inert_flux'].values
reactant_flux = reaction_data['A_flux']
# scaling the reactant flux 
reactant_flux_scaled = reactant_flux * 2.3
reactant_flux_scaled_smaller = reactant_flux * .23
df = pd.DataFrame({'inert':inert_flux, 'reactant':reactant_flux, 'reactant (2.3)':reactant_flux_scaled, 'reactant (0.23)':reactant_flux_scaled_smaller})
tapsap.plot_tap(times, df, legend = True)

Note that the second argument in calibration_teak is targeting the inert flux and we are not supplying information about the true reactant scale.

In [6]:

# applying calibration_teak
#
back_transformed_flux = tapsap.tap_mix(reactant_flux_scaled, inert_flux, times, fit_intercept=False)
df = pd.DataFrame({'inert':inert_flux, 'reactant':reactant_flux, 'fit flux':back_transformed_flux['flux']})
tapsap.plot_tap(times, df, legend = True)

In [7]:

# printing out the estimated scaling value
print(1 / back_transformed_flux['calibration_coef'])

2.299999938964193

In [8]:

2.3 - 1 / back_transformed_flux['calibration_coef']

Out[8]:

6.103580663108232e-08

In [9]:

# applying calibration_teak
#
back_transformed_flux = tapsap.tap_mix(reactant_flux_scaled_smaller, inert_flux, times, fit_intercept=False)
df = pd.DataFrame({'inert':inert_flux, 'reactant':reactant_flux, 'fit flux':back_transformed_flux['flux']})
tapsap.plot_tap(times, df, legend = True)

In [10]:

# printing out the estimated scaling value
print(1 / back_transformed_flux['calibration_coef'])

0.2299999998591788

In [11]:

0.23 - 1 / back_transformed_flux['calibration_coef']

Out[11]:

1.4082121579939155e-10

This example shows the ability of estimating the calibration coefficient for an irreversible reaction. When the species is reversible, the mean residence time of the species flux will be greater than the mean residence time of the inert flux. In this case, the species flux area is scaled to the inert flux area.

Application to a Transient object¶

The above code can be applied to each value of the dataframe, but can also be used in the method of the transient class called calibrate_flux. This method has the following arguments: calibration_amount (if a value is given, then it uses the area based calibration), reference_index (calibration to a specific flux), smooth_flux (if smoothing should be applied), or huber_loss (when outliers are present in the data). When the reference_index is not None, then this will loop over all flux and calibrate to a specific flux. The reference flux is usefull when accounting for drift in the inert flux.

In [12]:

# read in the data and apply baseline correction
data = tapsap.read_tdms('../tapsap/data/argon_100C.tdms')
transient_info = data.species_data['AMU_40_1']
transient_info.baseline_correct(baseline_time_range = [4.5, 5])
tapsap.plot_tap(transient_info.times, transient_info.flux.iloc[:,10].values)

In [13]:

# apply the calibration coefficient
transient_info.calibrate_flux(2)
tapsap.plot_tap(transient_info.times, transient_info.flux.iloc[:,10].values)