More advanced grouping of reference material selections

LuisK

Hello,

I am conducting isotope ratio analysis and using a custom DRS to calculate the isotopic value directly within iolite. The DRS includes standard bracketing using a spline of my standards.

My analytical structure is currently looking like this: Primary std- Secondary std- Primary std- 4 x unknown samples - Primary std - Secondary std - Primary std - ... - Primary std - Secondary std - Primary std.

Ideally, I would like to calculate the isotopic value by using the average of each block of primary standards and use this average to standard bracket the values between the corresponding blocks using the StepLinear function. In other words, I would like to take the average of both two primary standards of each block and use the StepLinear "spline" to connect them and to correct the ratio of the unknown analysis between them.

My question would be if there is any option to do this within iolite. Let me know if my situation is unclear and I will attempt to explain it better!

Thanks

Bence

Hi @LuisK

There is always a way to do it! It's just how best to do it. The complication I foresee here is how to combine the RM results into groups before calculating their average. We do the same thing for 3D Trace Elements, and we have a couple of algorithms for finding blocks. The simplest of which is just that the time between selections are smaller within blocks, and larger between blocks. Depending on how long your unknowns are run for, this could be almost foolproof or it could be a little tricky.

Once you have your blocks "grouped" I would calculate the mid-time of the block, and set the result at that midtime to the average. You could then spline/interpolate between these values to create your correction factor.

If you wanted to add this to your custom DRS yourself, you could take a look at what we've done with 3D Trace Elements:

https://github.com/iolite-LA-ICP-MS/iolite4-python-examples/blob/master/drs/3d_trace_elements.py

The function that creates the blocks starts at Line 526.

To calculate a spline from those data, you can use the spline function:

data.spline(NumpyArray x, NumpyArray y, NumpyArray w, str splineTypeName)

That function will return a spline that has been fitted to the arrays provided (x being your block midtime values, y being the averages of each block and w being the uncertainty of each block). splineTypeName will be the name of a spline type, such as "Spline_AutoSmooth"

Otherwise, feel free to contact us at the iolite support email address and we can help.

Kind regards,
Bence

LuisK

Hi Bence, thanks for the help again.

My DRS is based on the U-Pb DRS and includes baseline subtraction, calculation of an isotopic ratio, downhole fractionation correction, and calculation of a final result based on this ratio.

Bence added the grouping of reference material blocks based on the longer time between each standard analysis of one block compared to the shorter time within one block. I adapted the code to function more flexible.
First of all the code requires the import of several libraries:

import numpy as np import itertools from datetime import datetime

Then this is the part of the code handling the grouping and assignment of selection midtimes
`rms = [settings['ReferenceMaterial']] # Can also just be the name of your reference material
groups = [data.selectionGroup(rm) for rm in rms if rm]
selections = list(itertools.chain(*[sg.selections() for sg in groups]))

if len(selections) == 0:
print('No selections to find blocks for!')
raise RuntimeError('No selections to find blocks for!')

Create a list of component selections

component_sels = list(itertools.chain(*[s.linkedSelections() for s in selections if s.hasLinks()]))

Now kick them out

selections = list(filter(lambda s: s.property('UUID') not in component_sels, selections))

def sel_sorter(sel):
if not sel.isLinked():
return sel.midTimestamp
else:
return sel.linkedMidTimestamp()
selections.sort(key=sel_sorter)
selMidTimes = [s.midTimestamp if not s.isLinked() else s.linkedMidTimestamp() for s in selections]
diffs = np.column_stack( (range(len(selMidTimes)), np.insert(np.diff(selMidTimes), 0, 0)))
cutoff = np.mean(diffs[:, 1])

current_label = 1
labels = []
for i, v in enumerate(diffs[:, 1]):
    if v > cutoff:
        current_label += 1
    labels.append(current_label)

block_selections = {}
for k in np.unique(labels):
    matches = np.where(np.array(labels).astype(int) == k)[0]
    ind = [i for i in matches]
    block_selections[k] = list(np.array(selections)[ind])

# Now we have the blocks, we can calculate the block means and midtimes
block_means = []
block_midtimes = []
for b in block_selections.keys():
    print(f'Block {b}')
    sels = block_selections[b]
    for s in sels:
        print(f'\t{s.name}')

    block_midtime = np.mean([s.midTimestamp if not s.isLinked() else s.linkedMidTimestamp() for s in sels])
    print(f'Block midtime: {block_midtime}: {datetime.fromtimestamp(block_midtime).strftime("%Y-%m-%d %H:%M:%S")}')
    block_midtimes.append(block_midtime)

    # Change this to the channel you want to average
    channel = 'Name of your timeseries'
    ts = data.timeSeries(channel)

    block_vals = [data.result(s, ts).value() for s in sels]
    block_mean = np.mean(block_vals, axis=0)
    print(f'Block mean: {block_mean}')
    block_means.append(block_mean)`

Now that the blocks are created you can also verify that this part of the code worked properly, open the python command window (SHIFT + CTRL + P) to see which selections have been grouped in blocks.

The next step would be to use the block_mean and block_midtimes to interpolate the data over the index time to obtain either a timeseries or use its spline to do any further calculation such as standard-bracketing.

interp_means = np.interp(indexChannel.time(), block_midtimes, block_means, left=block_means[0], right=block_means[-1]) data.createTimeSeries('BlockMeans', data.Intermediate, indexChannel.time(), interp_means, commonProps)

This will have created a time series so you can observe the data in the timeseries view for further confirmation.
If you prefer to use the spline of this timeseries you can further calculate the spline like this:

sp = data.spline('Name of your reference material', 'BlockMeans') sp.data() # You can access the y data of the spline with this line

And that is all I added to get the wanted the result. After these steps I follow the examples given in the U-Pb DRS to standard-bracket my unknown analysis and calculate the final result.

Hope this helps anyone who has a similar question!